minerender 2.1.0-alpha.3 → 2.1.0-alpha.30

package/dist/node/index.js

@@ -28,14 +28,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
 
 // ../../node_modules/ts-deepmerge/dist/index.js
 var require_dist = __commonJS({
@@ -45,8 +37,8 @@ var require_dist = __commonJS({
       __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
           s = arguments[i];
-          for (var p13 in s) if (Object.prototype.hasOwnProperty.call(s, p13))
-            t[p13] = s[p13];
+          for (var p12 in s) if (Object.prototype.hasOwnProperty.call(s, p12))
+            t[p12] = s[p12];
         }
         return t;
       };
@@ -90,7 +82,7 @@ var require_dist = __commonJS({
       return false;
     };
     var PROTECTED_KEYS = ["__proto__"];
-    var merge11 = function() {
+    var merge10 = function() {
       var objects = [];
       for (var _i = 0; _i < arguments.length; _i++) {
         objects[_i] = arguments[_i];
@@ -101,9 +93,9 @@ var require_dist = __commonJS({
             return;
           }
           if (Array.isArray(result[key]) && Array.isArray(current[key])) {
-            result[key] = merge11.options.mergeArrays ? Array.from(new Set(result[key].concat(current[key]))) : current[key];
+            result[key] = merge10.options.mergeArrays ? Array.from(new Set(result[key].concat(current[key]))) : current[key];
           } else if (isObject(result[key]) && isObject(current[key])) {
-            result[key] = merge11(result[key], current[key]);
+            result[key] = merge10(result[key], current[key]);
           } else {
             result[key] = current[key];
           }
@@ -114,18 +106,18 @@ var require_dist = __commonJS({
     var defaultOptions = {
       mergeArrays: true
     };
-    merge11.options = defaultOptions;
-    merge11.withOptions = function(options) {
+    merge10.options = defaultOptions;
+    merge10.withOptions = function(options) {
       var objects = [];
       for (var _i = 1; _i < arguments.length; _i++) {
         objects[_i - 1] = arguments[_i];
       }
-      merge11.options = __assign({ mergeArrays: true }, options);
-      var result = merge11.apply(void 0, __spreadArray([], __read(objects), false));
-      merge11.options = defaultOptions;
+      merge10.options = __assign({ mergeArrays: true }, options);
+      var result = merge10.apply(void 0, __spreadArray([], __read(objects), false));
+      merge10.options = defaultOptions;
       return result;
     };
-    exports2.default = merge11;
+    exports2.default = merge10;
   }
 });
 
@@ -135,6 +127,7 @@ __export(index_node_exports, {
   AXES: () => AXES,
   ArchiveAssetSource: () => ArchiveAssetSource,
   AssetKey: () => AssetKey,
+  AssetLoadError: () => AssetLoadError,
   AssetLoader: () => AssetLoader,
   AssetParser: () => AssetParser,
   AssetSource: () => AssetSource,
@@ -144,9 +137,9 @@ __export(index_node_exports, {
   BUILTIN_GENERATED: () => BUILTIN_GENERATED,
   BasicAssetKey: () => BasicAssetKey,
   BatchedExecutor: () => BatchedExecutor,
-  BlockEntityModels: () => BlockEntityModels,
   BlockObject: () => BlockObject,
   BlockStates: () => BlockStates,
+  BlockTints: () => BlockTints,
   BrowserArchiveProxy: () => BrowserArchiveProxy,
   CUBE_FACES: () => CUBE_FACES,
   Caching: () => Caching,
@@ -161,8 +154,8 @@ __export(index_node_exports, {
   DISPLAY_POSITIONS: () => DISPLAY_POSITIONS,
   DefaultBlockStates: () => DefaultBlockStates,
   DisplayPosition: () => DisplayPosition,
+  DisplayTransforms: () => DisplayTransforms,
   Entities: () => Entities,
-  EntityModels: () => EntityModels,
   EntityObject: () => EntityObject,
   Env: () => Env,
   Geometries: () => Geometries,
@@ -192,6 +185,7 @@ __export(index_node_exports, {
   OrbitControls: () => OrbitControls,
   PersistentCache: () => PersistentCache,
   Renderer: () => Renderer,
+  RequestError: () => RequestError,
   Requests: () => Requests,
   SKIN_PARTS: () => SKIN_PARTS,
   SceneInspector: () => SceneInspector,
@@ -201,6 +195,7 @@ __export(index_node_exports, {
   SchematicParser: () => SchematicParser,
   SkinObject: () => SkinObject,
   SkinPart: () => SkinPart,
+  SkinTextures: () => SkinTextures,
   Skins: () => Skins,
   StructureParser: () => StructureParser,
   TextureAtlas: () => TextureAtlas,
@@ -215,10 +210,10 @@ __export(index_node_exports, {
   addWireframeToObject: () => addWireframeToObject,
   applyElementRotation: () => applyElementRotation,
   applyGenericRotation: () => applyGenericRotation,
-  applyModelPartRotation: () => applyModelPartRotation,
   axisToVec3: () => axisToVec3,
   base64decode: () => base64decode,
   base64encode: () => base64encode,
+  capeTextureSizes: () => capeTextureSizes,
   captureException: () => captureException,
   changeEvent: () => changeEvent,
   clampRotationDegrees: () => clampRotationDegrees,
@@ -302,25 +297,29 @@ var Env = class {
 };
 
 // src/cache/PersistentCache.ts
-var _PersistentCache = class _PersistentCache {
+var PersistentCache = class _PersistentCache {
   constructor(backing) {
     this.backing = backing;
   }
+  static {
+    /** Bump to invalidate every persisted entry. */
+    this.VERSION = 2;
+  }
   static open(name) {
     return Env.provider.openCache(name, _PersistentCache.VERSION);
   }
+  /** Loads a missing entry and stores only non-nullish results. */
   async getOrLoad(key, loader) {
     let v = await this.get(key);
     if (typeof v === "undefined" || v === null) {
       v = await loader(key);
-      await this.put(key, v);
+      if (typeof v !== "undefined" && v !== null) {
+        await this.put(key, v);
+      }
     }
     return v;
   }
 };
-/** Bump to invalidate every persisted entry. */
-_PersistentCache.VERSION = 1;
-var PersistentCache = _PersistentCache;
 
 // src/env/node/NodeCache.ts
 var NodeCache = class extends PersistentCache {
@@ -398,7 +397,7 @@ registerNodeEnv();
 // src/Axis.ts
 var import_three = require("three");
 var Axis = /* @__PURE__ */ ((Axis3) => {
-  Axis3["X"] = "X";
+  Axis3["X"] = "x";
   Axis3["Y"] = "y";
   Axis3["Z"] = "z";
   return Axis3;
@@ -406,7 +405,7 @@ var Axis = /* @__PURE__ */ ((Axis3) => {
 var AXES = Object.values(Axis);
 function axisToVec3(axis) {
   switch (axis) {
-    case "X" /* X */:
+    case "x" /* X */:
       return new import_three.Vector3(1, 0, 0);
     case "y" /* Y */:
       return new import_three.Vector3(0, 1, 0);
@@ -494,8 +493,7 @@ function serializeImageKey(key) {
   return md5(key.src);
 }
 function serializeBoxGeometryKey(key) {
-  var _a;
-  return md5([key.width, key.height, key.depth, (_a = key.uv) == null ? void 0 : _a.join(":")].join("_"));
+  return md5([key.width, key.height, key.depth, key.uv?.join(":")].join("_"));
 }
 function serializeTextureKey(key) {
   return md5([key.src, key.format, key.rotation].join("$"));
@@ -510,7 +508,67 @@ function serializeMeshKey(key) {
 // src/cache/Caching.ts
 var import_loading_cache = require("@inventivetalent/loading-cache");
 var import_time = require("@inventivetalent/time");
-var Caching = class {
+var Caching = class _Caching {
+  static {
+    this.rawImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(5)).buildAsync();
+  }
+  static {
+    this.imageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
+  }
+  static {
+    this.canvasImageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
+  }
+  static {
+    this.wrappedImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
+  }
+  static {
+    this.boxGeometryCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(20)).build();
+  }
+  static {
+    this.textureCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
+  }
+  static {
+    this.materialCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
+  }
+  static {
+    this.boxMeshCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
+  }
+  static {
+    this.textureAssetCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+  }
+  static {
+    this.textureMetaCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+  }
+  static {
+    this.rawModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+  }
+  static {
+    this.mergedModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+  }
+  static {
+    this.modelTextureAtlasCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+  }
+  static {
+    this.blockStateCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+  }
+  static {
+    this.listAssetCache = _Caching.createAssetCache();
+  }
+  static {
+    this.defaultBlockStatesCache = _Caching.createAssetCache();
+  }
+  static {
+    this.blockTintCache = _Caching.createAssetCache();
+  }
+  static {
+    this.entityModelCache = _Caching.createAssetCache();
+  }
+  static {
+    this.entityTextureCache = _Caching.createAssetCache();
+  }
+  static createAssetCache() {
+    return import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
+  }
   /** Every cache above, so clear()/end() can never fall out of sync with the field list again. */
   static get all() {
     return [
@@ -527,7 +585,12 @@ var Caching = class {
       this.rawModelCache,
       this.mergedModelCache,
       this.modelTextureAtlasCache,
-      this.blockStateCache
+      this.blockStateCache,
+      this.listAssetCache,
+      this.defaultBlockStatesCache,
+      this.blockTintCache,
+      this.entityModelCache,
+      this.entityTextureCache
     ];
   }
   static clear() {
@@ -538,8 +601,8 @@ var Caching = class {
   /**
    * Clears every cache and stops its expiry timer.
    *
-   * loading-cache reschedules that timer indefinitely, so a Node process will not exit until
-   * this is called - see {@link shutdown}.
+   * Expiry timers are unref'd in Node, so idle processes can exit without this cleanup.
+   * Use {@link shutdown} to also stop requests and the shared Ticker.
    */
   static end() {
     for (const cache of this.all) {
@@ -553,20 +616,6 @@ var Caching = class {
     };
   }
 };
-Caching.rawImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(5)).buildAsync();
-Caching.imageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
-Caching.canvasImageDataCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
-Caching.wrappedImageCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(10)).buildAsync();
-Caching.boxGeometryCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(20)).build();
-Caching.textureCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
-Caching.materialCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
-Caching.boxMeshCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).build();
-Caching.textureAssetCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.textureMetaCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.rawModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.mergedModelCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.modelTextureAtlasCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
-Caching.blockStateCache = import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
 
 // src/Geometries.ts
 var Geometries = class _Geometries {
@@ -587,13 +636,14 @@ var Geometries = class _Geometries {
 };
 
 // src/Materials.ts
-var import_three6 = require("three");
+var import_three5 = require("three");
 
 // src/texture/Textures.ts
-var import_three5 = require("three");
+var import_three4 = require("three");
 
 // src/texture/TextureLoader.ts
-var import_three4 = require("three");
+var import_three3 = require("three");
+var THREE = __toESM(require("three"));
 
 // src/canvas/CanvasCompat.ts
 function createImage(width, height) {
@@ -604,9 +654,7 @@ function createCanvas2(width, height) {
 }
 
 // src/request/Requests.ts
-var import_axios = __toESM(require("axios"));
 var import_jobqu = require("jobqu");
-var import_time2 = require("@inventivetalent/time");
 
 // src/util/log.ts
 var Reset = "\x1B[0m";
@@ -616,198 +664,174 @@ function prefix(prefix2) {
   return `${FgGreen}MR${BgBlack}${prefix2 ?? ""}${Reset}`;
 }
 
-// src/util/BatchedExecutor.ts
-var BatchedExecutor = class {
-  constructor(interval = 1, batch = 30) {
-    this.interval = interval;
-    this.batch = batch;
-    this.queue = [];
-    this.task = setInterval(() => this.run());
-  }
-  submit(task) {
-    this.queue.push(task);
-  }
-  run() {
-    for (let i = 0; i < this.batch; i++) {
-      this.runNext();
-    }
-  }
-  runNext() {
-    let next = this.queue.shift();
-    if (next) next();
+// src/request/Requests.ts
+var p = prefix("Requests");
+var RequestError = class extends Error {
+  constructor(message, response, cause) {
+    super(message);
+    this.response = response;
+    this.cause = cause;
+    this.name = "RequestError";
   }
 };
-
-// src/util/model.ts
-var import_three3 = require("three");
-function applyElementRotation(rotation, geometry) {
-  const origin = new import_three3.Vector3(rotation.origin[0], rotation.origin[1], rotation.origin[2]);
-  geometry.translate(-origin.x, -origin.y, -origin.z);
-  switch (rotation.axis) {
-    case "X" /* X */:
-      geometry.rotateX(toRadians(rotation.angle));
-      break;
-    case "y" /* Y */:
-      geometry.rotateY(toRadians(rotation.angle));
-      break;
-    case "z" /* Z */:
-      geometry.rotateZ(toRadians(rotation.angle));
-      break;
-  }
-  if (rotation.rescale) {
-    if (Math.abs(rotation.angle) === 22.5) {
-      const s = 1 / Math.cos(0.39269909262657166);
-      geometry.scale(s, 1, s);
-    } else {
-      const s = 1 / Math.cos(0.7853981852531433);
-      geometry.scale(s, 1, s);
+async function fetchRequest(config, defaultBaseURL) {
+  const { url, baseURL = defaultBaseURL, timeout = 5e3, responseType = "json", signal, ...options } = config;
+  const target = baseURL && !/^([a-z][a-z\d+.-]*:|\/\/)/i.test(url) ? `${baseURL.replace(/\/+$/, "")}/${url.replace(/^\/+/, "")}` : url;
+  const headers = new Headers(options.headers);
+  if (typeof window === "undefined" && !headers.has("User-Agent")) {
+    headers.set("User-Agent", "MineRender");
+  }
+  const attemptSignal = AbortSignal.any([
+    ...signal ? [signal] : [],
+    ...timeout === 0 ? [] : [AbortSignal.timeout(timeout)]
+  ]);
+  const request = new Request(target, { ...options, headers, signal: attemptSignal });
+  attemptSignal.throwIfAborted();
+  try {
+    const response = await fetch(request);
+    const result = {
+      data: void 0,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      url: response.url
+    };
+    if (!response.ok) {
+      await response.body?.cancel().catch(() => {
+      });
+      throw new RequestError(`Request failed with status ${response.status}`, result);
+    }
+    const emptyBody = request.method === "HEAD" || response.status === 204 || response.status === 205;
+    const data = responseType === "arraybuffer" ? await response.arrayBuffer() : emptyBody || response.body === null ? void 0 : await response.json();
+    return { ...result, data };
+  } catch (error) {
+    attemptSignal.throwIfAborted();
+    if (/^https?:/.test(request.url) && request.redirect !== "error" && error instanceof TypeError) {
+      throw new RequestError("Network request failed", void 0, error);
     }
+    throw error;
   }
-  geometry.translate(origin.x, origin.y, origin.z);
-}
-function applyModelPartRotation(modelPart, geometry) {
-  const origin = new import_three3.Vector3(modelPart.pivotX, modelPart.pivotY, modelPart.pivotZ);
-  geometry.translate(-origin.x, -origin.y, -origin.z);
-  geometry.rotateX(toRadians(modelPart.pitch));
-  geometry.rotateY(toRadians(modelPart.yaw));
-  geometry.rotateZ(toRadians(modelPart.roll));
-  geometry.translate(origin.x, origin.y, origin.z);
 }
-function applyGenericRotation(axis, rotation, obj) {
-  switch (axis) {
-    case "X" /* X */:
-      obj.rotateOnAxis(new import_three3.Vector3(1, 0, 0), toRadians(rotation));
-      break;
-    case "y" /* Y */:
-      obj.rotateOnAxis(new import_three3.Vector3(0, 1, 0), toRadians(rotation));
-      break;
-    case "z" /* Z */:
-      obj.rotateOnAxis(new import_three3.Vector3(0, 0, 1), toRadians(rotation));
-      break;
+async function abortable(promise, signal) {
+  if (!signal) return promise;
+  let abort;
+  const cancelled = new Promise((_, reject) => {
+    abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+  });
+  try {
+    return await Promise.race([promise, cancelled]);
+  } finally {
+    signal.removeEventListener("abort", abort);
   }
 }
-function addBox3WireframeToObject(box, obj, color = 16777215, w = 2) {
-  let size = new import_three3.Vector3();
-  box.getSize(size);
-  let boxGeo = new import_three3.BoxGeometry(size.x, size.y, size.z, 1, 1, 1);
-  let wireGeo = new import_three3.EdgesGeometry(boxGeo);
-  let wireMat = new import_three3.LineBasicMaterial({ color, linewidth: w });
-  let wireframe = new import_three3.LineSegments(wireGeo, wireMat);
-  obj.add(wireframe);
-  let axes = new import_three3.AxesHelper(1);
-  obj.add(axes);
-}
-function addWireframeToObject(obj, color = 16777215, w = 2) {
-  let boxGeo = new import_three3.BoxGeometry(16, 16, 16, 1, 1, 1);
-  let wireGeo = new import_three3.EdgesGeometry(boxGeo);
-  let wireMat = new import_three3.LineBasicMaterial({ color, linewidth: w });
-  let wireframe = new import_three3.LineSegments(wireGeo, wireMat);
-  obj.add(wireframe);
-  let axes = new import_three3.AxesHelper(1);
-  obj.add(axes);
-}
-function addWireframeToMesh(geo, mesh, color = 16777215, w = 2) {
-  let wireGeo = new import_three3.EdgesGeometry(geo);
-  let wireMat = new import_three3.LineBasicMaterial({ color, linewidth: w });
-  let wireframe = new import_three3.LineSegments(wireGeo, wireMat);
-  mesh.add(wireframe);
-  let axes = new import_three3.AxesHelper(1);
-  mesh.add(axes);
-}
-
-// src/util/performance.ts
-function captureException(e, ...extra) {
-  console.error(e, extra);
-}
-function timingStart(marker) {
-  console.time(marker);
-}
-function timingEnd(marker) {
-  console.timeEnd(marker);
-}
-
-// src/util/three.ts
-function isObject3D(obj) {
-  return obj.isObject3D;
-}
-function isMesh(obj) {
-  return obj.isMesh;
-}
-function isInstancedMesh(obj) {
-  return obj.isInstancedMesh;
-}
-function isPerspectiveCamera(obj) {
-  return obj.isPerspectiveCamera;
-}
-function isOrthographicCamera(obj) {
-  return obj.isOrthographicCamera;
-}
-
-// src/request/Requests.ts
-var p = prefix("Requests");
-if (typeof window === "undefined") {
-  import_axios.default.defaults.headers["User-Agent"] = "MineRender";
-}
-var _Requests = class _Requests {
-  static genericRequest(request) {
-    return this.genericQueue.add(request).catch(async (e) => {
-      console.debug(p, "generic catch", e.code, e);
-      if (this.shouldRetry(e, request)) {
-        await sleep(100);
-        return this.genericRequest(request);
-      }
-      throw e;
-    });
-  }
-  static mcAssetRequest(request) {
-    return this.mcAssetRequestQueue.add(request).catch((e) => {
-      console.debug(p, "mcAssetRequest catch", e.code, e);
-      throw e;
-    });
+var RequestQueue = class {
+  constructor() {
+    this.pendingRequests = 0;
+    this.stopped = new AbortController();
+    this.queue = new import_jobqu.JobQueue(
+      (request) => fetchRequest(request, this.baseURL),
+      { interval: 10, maxPerRun: 1, maxActive: 8 }
+    );
   }
-  static shouldRetry(e, request) {
-    if ("code" in e) {
-      if ("ECONNABORTED" === e.code) {
-        if ("minerenderRetry" in request) {
-          if (request["minerenderRetry"] > 0) {
-            request["minerenderRetry"]--;
-            return true;
+  async request(request) {
+    this.pendingRequests++;
+    const signal = request.signal;
+    try {
+      for (let retries = 0; ; retries++) {
+        signal?.throwIfAborted();
+        try {
+          return await abortable(this.queue.add(request), signal);
+        } catch (error) {
+          console.debug(p, "Request failed", error);
+          const delay = this.retryDelay(error, request, retries);
+          if (delay === void 0) {
+            throw error;
           }
-        } else {
-          request["minerenderRetry"] = 3;
-          return true;
+          await this.waitForRetry(delay, signal);
         }
       }
+    } finally {
+      if (signal?.aborted) {
+        this.queue.remove(request);
+      }
+      this.pendingRequests--;
     }
-    return false;
+  }
+  retryDelay(error, request, retries) {
+    if (this.stopped.signal.aborted || retries >= 3 || (request.method ?? "get").toLowerCase() !== "get" || request.signal?.aborted) {
+      return void 0;
+    }
+    if (error instanceof RequestError) {
+      const status = error.response?.status;
+      if (status !== void 0 && status !== 408 && status !== 429 && !(status >= 500 && status < 600)) return void 0;
+    } else if (!(error instanceof DOMException && error.name === "TimeoutError")) {
+      return void 0;
+    }
+    let delay = 100 * 2 ** retries;
+    const retryAfter = error instanceof RequestError ? error.response?.headers.get("Retry-After") : void 0;
+    if (retryAfter !== void 0 && retryAfter !== null) {
+      const seconds = Number(retryAfter);
+      if (!retryAfter.trim() || !Number.isFinite(seconds) || seconds < 0) {
+        return void 0;
+      }
+      delay = Math.max(delay, seconds * 1e3);
+    }
+    return delay;
+  }
+  async waitForRetry(delay, signal) {
+    let timer;
+    const waiting = new Promise((resolve) => {
+      timer = setTimeout(resolve, delay);
+    });
+    try {
+      await abortable(waiting, AbortSignal.any([this.stopped.signal, ...signal ? [signal] : []]));
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  get pendingSize() {
+    return this.pendingRequests;
+  }
+  end() {
+    this.queue.end();
+    this.stopped.abort(new import_jobqu.JobCancelledError("ended"));
+  }
+};
+var Requests = class {
+  static {
+    this.genericQueue = new RequestQueue();
+  }
+  static {
+    this.mcAssetRequestQueue = new RequestQueue();
+  }
+  static genericRequest(request) {
+    return this.genericQueue.request(request);
+  }
+  static mcAssetRequest(request) {
+    return this.mcAssetRequestQueue.request(request);
   }
   static setMcAssetRoot(root) {
-    this.mcAssetInstance.defaults.baseURL = root;
+    this.mcAssetRequestQueue.baseURL = root;
   }
+  /** Counts unsettled calls, including retry delays and requests still running after shutdown. */
   static get queueSizes() {
     return {
-      generic: this.genericQueue.size,
-      mcAsset: this.mcAssetRequestQueue.size
+      generic: this.genericQueue.pendingSize,
+      mcAsset: this.mcAssetRequestQueue.pendingSize
     };
   }
   /**
-   * Stops both queue timers. jobqu reschedules itself indefinitely, so a Node process will not
-   * exit until this is called - see {@link shutdown}.
+   * Permanently stops both queues and rejects waiting, retrying, and future requests.
+   * Requests already running can finish. Idle queues hold no timer, so Node can exit without
+   * this cleanup. See {@link shutdown}.
    */
   static end() {
     this.genericQueue.end();
     this.mcAssetRequestQueue.end();
   }
 };
-_Requests.axiosInstance = import_axios.default.create({
-  timeout: 5e3
-});
-_Requests.mcAssetInstance = import_axios.default.create({
-  timeout: 5e3
-});
-_Requests.genericQueue = new import_jobqu.JobQueue((request) => _Requests.axiosInstance.request(request), import_time2.Time.millis(10), 1);
-_Requests.mcAssetRequestQueue = new import_jobqu.JobQueue((request) => _Requests.mcAssetInstance.request(request), import_time2.Time.millis(10), 1);
-var Requests = _Requests;
 
 // src/WrappedImage.ts
 var WrappedImage = class {
@@ -845,10 +869,10 @@ var WrappedImage = class {
     return this.animated ? this.width : this.height;
   }
   get frameCount() {
-    return this.height / this.width;
+    return this.height / this.frameHeight;
   }
   getFrameY(frame) {
-    return this.height / this.frameCount * Math.max(0, Math.min(this.frameCount, frame));
+    return this.frameHeight * Math.max(0, Math.min(this.frameCount - 1, frame));
   }
   getSectionData(sx, sy, sw, sh) {
     return this.dta.data.getImageData(sx, sy, sw, sh);
@@ -858,7 +882,7 @@ var WrappedImage = class {
   }
   getFrameSectionData(frame) {
     const y = this.getFrameY(frame);
-    return this.getSectionData(0, y, this.width, this.width + y);
+    return this.getSectionData(0, y, this.frameWidth, this.frameHeight);
   }
 };
 
@@ -872,29 +896,41 @@ var ImageLoader = class _ImageLoader {
   static async loadAsync(src) {
     return new Promise((resolve, reject) => {
       const image = this._createImage();
-      image.src = src;
       image.onload = () => resolve(image);
-      image.onerror = (err) => reject(err);
+      image.onerror = (err) => reject(err instanceof Error ? err : new Error("Failed to decode image"));
+      image.src = src;
     });
   }
   static loadElement(src, onload, onerr) {
     const image = this._createImage();
-    image.src = src;
     if (onload)
       image.onload = onload;
     if (onerr)
       image.onerror = onerr;
+    image.src = src;
     return image;
   }
   static async loadData(src) {
     console.debug(p2, "loadData", src);
-    return await this.infoToData(await this.getInfo(src));
+    const image = await this.loadCanvasData(src);
+    return image.data.getImageData(0, 0, image.width, image.height);
   }
   static async loadCanvasData(src) {
-    return await this.infoToCanvasData(await this.getInfo(src));
+    const keyStr = serializeImageKey({ src });
+    const info = this.getInfo(src);
+    const cached = Caching.rawImageCache.getIfPresent(keyStr);
+    try {
+      return await this.infoToCanvasData(await info);
+    } catch (err) {
+      if (cached && Caching.rawImageCache.getIfPresent(keyStr) === cached) {
+        Caching.rawImageCache.invalidate(keyStr);
+      }
+      throw err;
+    }
   }
   static async infoToCanvasData(info) {
-    const image = await _ImageLoader.loadAsync(info.src);
+    const type = info.type === "jpg" ? "jpeg" : info.type ?? "png";
+    const image = await _ImageLoader.loadAsync(`data:image/${type};base64,${info.data.toString("base64")}`);
     const canvas = createCanvas2(info.width, info.height);
     const context = canvas.getContext("2d");
     context.drawImage(image, 0, 0);
@@ -905,11 +941,8 @@ var ImageLoader = class _ImageLoader {
     };
   }
   static async infoToData(info) {
-    const image = await _ImageLoader.loadAsync(info.src);
-    const canvas = createCanvas2(info.width, info.height);
-    const context = canvas.getContext("2d");
-    context.drawImage(image, 0, 0);
-    return context.getImageData(0, 0, canvas.width, canvas.height);
+    const image = await this.infoToCanvasData(info);
+    return image.data.getImageData(0, 0, image.width, image.height);
   }
   static async getData(src) {
     const keyStr = serializeImageKey({ src });
@@ -924,38 +957,25 @@ var ImageLoader = class _ImageLoader {
     });
   }
   static async processResponse(response) {
-    const src = response.config.url;
+    const src = response.url;
     const data = import_buffer.Buffer.from(response.data);
     const { width, height, type } = Env.provider.imageSize(data);
+    if (!width || !height) {
+      throw new Error("Invalid or unsupported image dimensions");
+    }
     return {
       src,
-      width: width || 0,
-      height: height || 0,
+      width,
+      height,
       type,
       data
     };
   }
   static async loadInfo(src) {
-    if (src.startsWith("data:image/png;base64")) {
-      return this.processResponse({
-        config: {
-          url: src
-        },
-        data: import_buffer.Buffer.from(src.substr("data:image/png;base64,".length), "base64")
-      });
-    }
     return Requests.genericRequest({
       url: src,
       responseType: "arraybuffer"
-    }).then(this.processResponse).catch((err) => {
-      return {
-        src,
-        width: 0,
-        height: 0,
-        type: void 0,
-        data: import_buffer.Buffer.from([0])
-      };
-    });
+    }).then(this.processResponse);
   }
   static async getInfo(src) {
     const keyStr = serializeImageKey({ src });
@@ -977,25 +997,39 @@ var ImageLoader = class _ImageLoader {
 
 // src/texture/TextureLoader.ts
 var TextureLoader = class {
+  static {
+    this.failedTextures = /* @__PURE__ */ new WeakSet();
+  }
+  /** Reports whether image loading failed, so cached textures can be retried. */
+  static hasFailed(texture) {
+    return this.failedTextures.has(texture);
+  }
   static createTexture() {
-    return new import_three4.Texture();
+    return new import_three3.Texture();
   }
-  static loadInBackground(src, format = import_three4.RGBAFormat, rotation = 0) {
+  static loadInBackground(src, format = import_three3.RGBAFormat, rotation = 0) {
     const texture = this.createTexture();
-    const image = ImageLoader.loadElement(src);
-    image.onload = function() {
+    texture.colorSpace = THREE.SRGBColorSpace;
+    const image = ImageLoader.loadElement(src, () => {
       texture.needsUpdate = true;
-    };
+    }, (error) => {
+      this.failedTextures.add(texture);
+      console.warn("Failed to load texture", src, error);
+    });
     texture.image = image;
     texture.format = format;
     texture.rotation = rotation;
     return Textures.initTextureProps(texture);
   }
-  static load(src, format = import_three4.RGBAFormat, rotation = 0) {
-    const texture = new import_three4.Texture();
+  static load(src, format = import_three3.RGBAFormat, rotation = 0) {
+    const texture = new import_three3.Texture();
+    texture.colorSpace = THREE.SRGBColorSpace;
     ImageLoader.getData(src).then((image) => {
-      texture.needsUpdate = true;
       texture.image = image;
+      texture.needsUpdate = true;
+    }).catch((error) => {
+      this.failedTextures.add(texture);
+      console.warn("Failed to load texture", src, error);
     });
     texture.format = format;
     texture.rotation = rotation;
@@ -1004,11 +1038,11 @@ var TextureLoader = class {
 };
 
 // src/texture/Textures.ts
-var THREE = __toESM(require("three"));
+var THREE2 = __toESM(require("three"));
 var Textures = class _Textures {
   static initTextureProps(texture) {
-    texture.magFilter = THREE.NearestFilter;
-    texture.minFilter = THREE.NearestFilter;
+    texture.magFilter = THREE2.NearestFilter;
+    texture.minFilter = THREE2.NearestFilter;
     texture.anisotropy = 0;
     return texture;
   }
@@ -1016,13 +1050,19 @@ var Textures = class _Textures {
     return TextureLoader.load(key.src, key.format, key.rotation);
   }
   static createAsset(key) {
-    return new import_three5.Texture();
+    return new import_three4.Texture();
   }
   static createCanvasTexture(canvas) {
-    return this.initTextureProps(new import_three5.CanvasTexture(canvas));
+    const texture = new import_three4.CanvasTexture(canvas);
+    texture.colorSpace = THREE2.SRGBColorSpace;
+    return this.initTextureProps(texture);
   }
   static getImage(key) {
     const keyStr = serializeTextureKey(key);
+    const cached = Caching.textureCache.peek(keyStr);
+    if (cached && TextureLoader.hasFailed(cached)) {
+      Caching.textureCache.invalidate(keyStr);
+    }
     return Caching.textureCache.get(keyStr, (k) => {
       return _Textures.createImage(key);
     });
@@ -1030,7 +1070,10 @@ var Textures = class _Textures {
 };
 
 // src/Materials.ts
-var _Materials = class _Materials {
+var Materials = class _Materials {
+  static {
+    this.MISSING_TEXTURE_SRC = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABAAQMAAACQp+OdAAAABlBMVEX/AP8AAACfphTyAAAAFUlEQVQoz2MIhQKGVVAwKjIqQrwIAHRz/wFI17TEAAAAAElFTkSuQmCC";
+  }
   // resolved lazily: as a static field this decoded an image the moment the library was
   // imported, which needs both a DOM and an EnvProvider to already be in place
   static get MISSING_TEXTURE() {
@@ -1038,26 +1081,26 @@ var _Materials = class _Materials {
   }
   static createImage(key) {
     const transparent = key.transparent || false;
-    return new import_three6.MeshBasicMaterial({
+    return new import_three5.MeshBasicMaterial({
       map: Textures.getImage(key.texture),
       transparent,
-      side: transparent ? import_three6.DoubleSide : import_three6.FrontSide,
+      side: transparent ? import_three5.DoubleSide : import_three5.FrontSide,
       alphaTest: 0.5
     });
   }
   static createBasicCanvasMaterial(canvas, transparent = false, shade = false) {
     if (shade) {
-      return new import_three6.MeshStandardMaterial({
+      return new import_three5.MeshStandardMaterial({
         map: Textures.createCanvasTexture(canvas),
         transparent,
-        side: transparent ? import_three6.DoubleSide : import_three6.FrontSide,
+        side: transparent ? import_three5.DoubleSide : import_three5.FrontSide,
         alphaTest: 0.5
       });
     }
-    return new import_three6.MeshBasicMaterial({
+    return new import_three5.MeshBasicMaterial({
       map: Textures.createCanvasTexture(canvas),
       transparent,
-      side: transparent ? import_three6.DoubleSide : import_three6.FrontSide,
+      side: transparent ? import_three5.DoubleSide : import_three5.FrontSide,
       alphaTest: 0.5
     });
   }
@@ -1066,6 +1109,7 @@ var _Materials = class _Materials {
             uniform bool SHADE;
             
             varying vec2 vUv;
+            varying vec3 vTint;
             varying float light;
             varying float lift;
 
@@ -1078,7 +1122,11 @@ var _Materials = class _Materials {
 
                 if (SHADE) {
 
-                    vec3 N = vec3( modelMatrix * instanceMatrix * vec4(normal, 0.0) );
+                    #ifdef USE_INSTANCING
+                        vec3 N = vec3( modelMatrix * instanceMatrix * vec4(normal, 0.0) );
+                    #else
+                        vec3 N = vec3( modelMatrix * vec4(normal, 0.0) );
+                    #endif
 
                     float yLight = (1.0+N.y) * 0.5;
                     light = yLight * (1.0-AMBIENT) + N.x*N.x * XFAC + N.z*N.z * ZFAC + AMBIENT;
@@ -1096,6 +1144,7 @@ var _Materials = class _Materials {
                 }
                 
                 vUv = uv;
+                vTint = color;
                
                 #ifdef USE_INSTANCING
                     gl_Position = projectionMatrix * viewMatrix * modelMatrix * instanceMatrix * vec4(position, 1.0);
@@ -1117,12 +1166,14 @@ var _Materials = class _Materials {
             uniform float BRIGHTNESS;
 
             varying vec2 vUv;
+            varying vec3 vTint;
             varying float light;
             varying float lift;
 
             void main(void)
             {
                 vec4 color = texture2D(map, vUv);
+                color.rgb *= vTint;
                 
                 if (color.a < 0.01) discard;
 
@@ -1136,16 +1187,19 @@ var _Materials = class _Materials {
                     gl_FragColor = vec4(lift + color.rgb * light2, 1.0);
 
                 }
+
+                #include <tonemapping_fragment>
+                #include <colorspace_fragment>
             }
         `;
     try {
-      return new import_three6.ShaderMaterial({
+      return new import_three5.ShaderMaterial({
         uniforms: {
           SHADE: { value: true },
           BRIGHTNESS: { value: 1 },
           EMISSIVE: { value: false },
           base: {
-            value: new import_three6.Color(12698049)
+            value: new import_three5.Color(12698049)
             /*TODO*/
           },
           map: { value: Textures.createCanvasTexture(canvas) }
@@ -1154,7 +1208,7 @@ var _Materials = class _Materials {
         fragmentShader: fragShader,
         vertexColors: true,
         transparent,
-        side: transparent ? import_three6.DoubleSide : import_three6.FrontSide,
+        side: transparent ? import_three5.DoubleSide : import_three5.FrontSide,
         alphaTest: 0.5
       });
     } catch (e) {
@@ -1164,6 +1218,10 @@ var _Materials = class _Materials {
   }
   static getImage(key) {
     const keyStr = serializeMaterialKey(key);
+    const map = Caching.materialCache.peek(keyStr)?.map;
+    if (map && TextureLoader.hasFailed(map)) {
+      Caching.materialCache.invalidate(keyStr);
+    }
     return Caching.materialCache.get(keyStr, (k) => {
       return _Materials.createImage(key);
     });
@@ -1184,14 +1242,12 @@ var _Materials = class _Materials {
     }
   }
 };
-_Materials.MISSING_TEXTURE_SRC = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABAAQMAAACQp+OdAAAABlBMVEX/AP8AAACfphTyAAAAFUlEQVQoz2MIhQKGVVAwKjIqQrwIAHRz/wFI17TEAAAAAElFTkSuQmCC";
-var Materials = _Materials;
 
 // src/Meshes.ts
-var import_three7 = require("three");
+var import_three6 = require("three");
 var Meshes = class _Meshes {
   static createBox(key) {
-    return new import_three7.Mesh(Geometries.getBox(key.geometry), Materials.getImage(key.material));
+    return new import_three6.Mesh(Geometries.getBox(key.geometry), Materials.getImage(key.material));
   }
   static getBox(key) {
     const keyStr = serializeMeshKey(key);
@@ -1202,7 +1258,7 @@ var Meshes = class _Meshes {
 };
 
 // src/UVMapper.ts
-var import_three8 = require("three");
+var import_three9 = require("three");
 
 // src/model/ModelMerger.ts
 var import_ts_deepmerge = __toESM(require_dist());
@@ -1238,9 +1294,10 @@ var AssetKey = class _AssetKey extends BasicAssetKey {
     this.rootType = rootType;
     this.extension = extension;
     this.root = root;
+    this.isAssetKey = true;
   }
   static parse(assetType, str, origin) {
-    let namespace = (origin == null ? void 0 : origin.namespace) || DEFAULT_NAMESPACE;
+    let namespace = origin?.namespace || DEFAULT_NAMESPACE;
     if (str.includes(":")) {
       let split2 = str.split(":");
       namespace = split2[0];
@@ -1253,12 +1310,15 @@ var AssetKey = class _AssetKey extends BasicAssetKey {
       split.shift();
     }
     let path = split.join("/");
-    let extension = assetType === "textures" ? ".png" : (origin == null ? void 0 : origin.assetType) || ".json";
-    return new _AssetKey(namespace, path, assetType, type, "assets", extension, origin == null ? void 0 : origin.root);
+    const extension = assetType === "textures" ? ".png" : origin?.extension ?? ".json";
+    if (extension && path.endsWith(extension)) {
+      path = path.slice(0, -extension.length);
+    }
+    return new _AssetKey(namespace, path, assetType, type, "assets", extension, origin?.root);
   }
   toString() {
     let a = [
-      typeof this.root !== "undefined" || AssetLoader.ROOT !== DEFAULT_ROOT ? this.root ?? AssetLoader.ROOT : "__root__",
+      this.root ?? AssetLoader.ROOT,
       this.rootType ?? "__rootType__",
       this.assetType ?? "__assetType__",
       this.type ?? "__type__",
@@ -1268,12 +1328,12 @@ var AssetKey = class _AssetKey extends BasicAssetKey {
     return a.join("/");
   }
   getFullPath() {
-    let p13 = [];
+    let p12 = [];
     if (this.type) {
-      p13.push(this.type);
+      p12.push(this.type);
     }
-    p13.push(this.path);
-    return p13.join("/");
+    p12.push(this.path);
+    return p12.join("/");
   }
   toNamespacedString() {
     return this.namespace + ":" + this.getFullPath();
@@ -1283,22 +1343,84 @@ var AssetKey = class _AssetKey extends BasicAssetKey {
   }
 };
 function isBasicAssetKey(obj) {
-  return "namespace" in obj && "path" in obj;
+  return obj !== null && typeof obj === "object" && typeof obj.namespace === "string" && typeof obj.path === "string";
 }
 function isAssetKey(obj) {
-  return isBasicAssetKey(obj) && "parse" in obj;
+  return isBasicAssetKey(obj) && obj.isAssetKey === true;
 }
 
+// src/model/DisplayTransforms.ts
+var import_three7 = require("three");
+
+// src/model/DisplayPosition.ts
+var DisplayPosition = /* @__PURE__ */ ((DisplayPosition2) => {
+  DisplayPosition2["THIRDPERSON_RIGHTHAND"] = "thirdperson_righthand";
+  DisplayPosition2["THIRDPERSON_LEFTHAND"] = "thirdperson_lefthand";
+  DisplayPosition2["FIRSTPERSON_RIGHTHAND"] = "firstperson_righthand";
+  DisplayPosition2["FIRSTPERSON_LEFTHAND"] = "firstperson_lefthand";
+  DisplayPosition2["GUI"] = "gui";
+  DisplayPosition2["HEAD"] = "head";
+  DisplayPosition2["GROUND"] = "ground";
+  DisplayPosition2["FIXED"] = "fixed";
+  DisplayPosition2["ON_SHELF"] = "on_shelf";
+  return DisplayPosition2;
+})(DisplayPosition || {});
+var DISPLAY_POSITIONS = Object.values(DisplayPosition);
+
+// src/model/DisplayTransforms.ts
+var DisplayTransforms = class {
+  /** Resolve hand fallbacks within one model, before inheriting parent display entries. */
+  static withHandFallbacks(display) {
+    if (!display) return void 0;
+    const resolved = { ...display };
+    for (const [left, right] of [
+      ["thirdperson_lefthand" /* THIRDPERSON_LEFTHAND */, "thirdperson_righthand" /* THIRDPERSON_RIGHTHAND */],
+      ["firstperson_lefthand" /* FIRSTPERSON_LEFTHAND */, "firstperson_righthand" /* FIRSTPERSON_RIGHTHAND */]
+    ]) {
+      if (resolved[left] === void 0 && resolved[right] !== void 0) resolved[left] = resolved[right];
+    }
+    return resolved;
+  }
+  /** Build a display pose for geometry already centered at the model's [8, 8, 8] pivot. */
+  static getMatrix(display, position) {
+    const transform = this.withHandFallbacks(display)?.[position] ?? {};
+    const left = position === "firstperson_lefthand" /* FIRSTPERSON_LEFTHAND */ || position === "thirdperson_lefthand" /* THIRDPERSON_LEFTHAND */;
+    const sign = left ? -1 : 1;
+    const [x, y, z] = transform.rotation ?? [0, 0, 0];
+    const rotation = new import_three7.Quaternion().setFromEuler(new import_three7.Euler(toRadians(x), sign * toRadians(y), sign * toRadians(z), "XYZ"));
+    const translation = new import_three7.Vector3(...transform.translation ?? [0, 0, 0]).clampScalar(-80, 80);
+    translation.x *= sign;
+    const scale = new import_three7.Vector3(...transform.scale ?? [1, 1, 1]).clampScalar(-4, 4);
+    return new import_three7.Matrix4().compose(translation, rotation, scale);
+  }
+  static apply(geometry, matrix) {
+    geometry.applyMatrix4(matrix);
+    if (matrix.determinant() < 0) {
+      if (!geometry.index) geometry.setIndex(Array.from({ length: geometry.getAttribute("position").count }, (_, i) => i));
+      const index = geometry.index;
+      for (let i = 0; i < index.count; i += 3) {
+        const second = index.getX(i + 1);
+        index.setX(i + 1, index.getX(i + 2));
+        index.setX(i + 2, second);
+      }
+      index.needsUpdate = true;
+    }
+  }
+};
+
 // src/model/ModelMerger.ts
 var ModelMerger = class {
   static async mergeWithParents(model) {
     const models = await this.collectAllParents(model);
     let merged = {};
-    for (let parentModel of models) {
-      merged = (0, import_ts_deepmerge.default)(merged, parentModel);
+    for (const source of [...models, model]) {
+      const inheritedDisplay = merged.display;
+      merged = import_ts_deepmerge.default.withOptions({ mergeArrays: false }, merged, source);
+      if (source.display) {
+        merged.display = { ...inheritedDisplay, ...DisplayTransforms.withHandFallbacks(source.display) };
+      }
     }
-    merged = (0, import_ts_deepmerge.default)(merged, model);
-    merged.hierarchy = models.map((m) => m.parent).filter((p13) => `${p13}`);
+    merged.hierarchy = models.map((m) => m.parent).filter((p12) => `${p12}`);
     merged.hierarchy.push(`${merged.parent}`);
     return merged;
   }
@@ -1308,6 +1430,7 @@ var ModelMerger = class {
     }
     const models = [];
     const parentKey = AssetKey.parse("models", model.parent);
+    parentKey.root = model.key?.root;
     const parentModel = await Models.getRaw(parentKey);
     if (parentModel) {
       models.unshift(parentModel);
@@ -1317,9 +1440,6 @@ var ModelMerger = class {
   }
 };
 
-// src/assets/Models.ts
-var import_typescript_memoize = require("typescript-memoize");
-
 // src/assets/source/parser/AssetParsers.ts
 var AssetParser = /* @__PURE__ */ ((AssetParser2) => {
   AssetParser2["MODEL"] = "model";
@@ -1333,30 +1453,65 @@ var AssetParser = /* @__PURE__ */ ((AssetParser2) => {
 })(AssetParser || {});
 
 // src/assets/Models.ts
-var _Models = class _Models {
+var Models = class _Models {
   // opened lazily: touching the store at import time would hit IndexedDB/disk just for loading
   // the library, and would require an EnvProvider before any entry has had a chance to register
   static get PERSISTENT_CACHE() {
     return this._persistentCache ??= PersistentCache.open("minerender-models");
   }
   static async getItemList() {
-    return AssetLoader.get(new AssetKey(
-      DEFAULT_NAMESPACE,
-      "_list",
-      "models",
-      "item",
-      "assets",
-      ".json",
-      DEFAULT_ROOT
-    ), "list" /* LIST */).then((r) => (r == null ? void 0 : r.files) ?? []);
+    const key = new AssetKey(DEFAULT_NAMESPACE, "_list", "items");
+    const legacyKey = new AssetKey(DEFAULT_NAMESPACE, "_list", "models", "item");
+    return Caching.listAssetCache.get(key.serialize(), async () => {
+      return (await AssetLoader.getFirst([key, legacyKey], "list" /* LIST */))?.asset;
+    }).then((r) => r?.files ?? []);
   }
   static async loadAndMerge(key) {
-    const model = await this.getRaw(key);
+    const model = key.type === "item" ? await this.getItemModel(key) : await this.getRaw(key);
     if (!model) {
       return void 0;
     }
     return ModelMerger.mergeWithParents(model);
   }
+  static async getItemModel(key) {
+    const itemKey = new AssetKey(key.namespace, key.path, "items", void 0, key.rootType, ".json", key.root);
+    const model = await this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(itemKey.serialize()), async () => {
+      const result = await AssetLoader.getFirst([itemKey, key], "json" /* JSON */);
+      if (!result) return void 0;
+      if (result.key.assetType !== "items") return { ...result.asset, key };
+      const reference = this.defaultItemModel(result.asset.model, key);
+      const modelKey = AssetKey.parse("models", reference);
+      modelKey.root = key.root;
+      const model2 = await this.getRaw(modelKey);
+      if (!model2) throw new Error(`Item ${key.toNamespacedString()} references missing model ${reference}`);
+      return model2;
+    });
+    return model ? { ...model, key: Object.assign(new AssetKey("", ""), model.key) } : void 0;
+  }
+  // Item previews use the GUI context, false conditions, and zero numeric properties.
+  static defaultItemModel(node, key) {
+    if (!node || typeof node.type !== "string") {
+      throw new Error(`Unsupported item model definition for ${key.toNamespacedString()}`);
+    }
+    switch (node.type.replace(/^minecraft:/, "")) {
+      case "model":
+        if (typeof node.model === "string" && node.model) return node.model;
+        break;
+      case "condition":
+        return this.defaultItemModel(node.on_false, key);
+      case "select": {
+        const selected = node.property?.replace(/^minecraft:/, "") === "display_context" ? node.cases?.find((entry) => Array.isArray(entry.when) ? entry.when.includes("gui") : entry.when === "gui")?.model : void 0;
+        return this.defaultItemModel(selected ?? node.fallback, key);
+      }
+      case "range_dispatch": {
+        const selected = node.entries?.reduce((match, entry) => {
+          return entry.threshold <= 0 && (!match || entry.threshold >= match.threshold) ? entry : match;
+        }, void 0);
+        return this.defaultItemModel(selected?.model ?? node.fallback, key);
+      }
+    }
+    throw new Error(`Unsupported item model ${node?.type ?? "definition"} for ${key.toNamespacedString()}`);
+  }
   static async getRaw(key) {
     if (!key.assetType) {
       key.assetType = "models";
@@ -1366,7 +1521,7 @@ var _Models = class _Models {
     }
     const keyStr = key.serialize();
     return Caching.rawModelCache.get(keyStr, (k) => {
-      return this.PERSISTENT_CACHE.getOrLoad(keyStr, (k1) => {
+      return this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
         return AssetLoader.get(key, "model" /* MODEL */);
       });
     }).then((asset) => {
@@ -1395,31 +1550,32 @@ var _Models = class _Models {
     return this.PERSISTENT_CACHE.clear();
   }
 };
-__decorateClass([
-  (0, import_typescript_memoize.Memoize)()
-], _Models, "getItemList", 1);
-var Models = _Models;
 
 // src/assets/BlockStates.ts
-var import_typescript_memoize2 = require("typescript-memoize");
 var BlockStates = class {
   static get PERSISTENT_CACHE() {
     return this._persistentCache ??= PersistentCache.open("minerender-blockstates");
   }
+  // BlockState names are hardcoded
   static async getList() {
-    return AssetLoader.get(new AssetKey(
+    const key = new AssetKey(
       DEFAULT_NAMESPACE,
       "_list",
       "blockstates",
       void 0,
       "assets",
       ".json",
-      DEFAULT_ROOT
-    ), "list" /* LIST */).then((r) => (r == null ? void 0 : r.files) ?? []);
+      AssetLoader.ROOT
+    );
+    return Caching.listAssetCache.get(key.serialize(), () => {
+      return AssetLoader.get(key, "list" /* LIST */);
+    }).then((r) => r?.files ?? []);
   }
   static async getDefaultStates() {
     const key = AssetKey.parse("blockstates", "minerender:defaultBlockStates");
-    return AssetLoader.get(key, "json" /* JSON */);
+    return Caching.defaultBlockStatesCache.get(key.serialize(), () => {
+      return AssetLoader.get(key, "json" /* JSON */);
+    });
   }
   static async getDefaultState(key) {
     const defaultStates = await this.getDefaultStates();
@@ -1437,7 +1593,7 @@ var BlockStates = class {
     }
     const keyStr = key.serialize();
     return Caching.blockStateCache.get(keyStr, (k) => {
-      return this.PERSISTENT_CACHE.getOrLoad(keyStr, (k1) => {
+      return this.PERSISTENT_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
         return AssetLoader.get(key, "blockstate" /* BLOCKSTATE */);
       });
     }).then((asset) => {
@@ -1458,17 +1614,11 @@ var BlockStates = class {
     await this.PERSISTENT_CACHE.clear();
   }
 };
-__decorateClass([
-  (0, import_typescript_memoize2.Memoize)()
-], BlockStates, "getList", 1);
-__decorateClass([
-  (0, import_typescript_memoize2.Memoize)()
-], BlockStates, "getDefaultStates", 1);
 var DefaultBlockStates = class {
 };
 
 // src/assets/Assets.ts
-var DEFAULT_ROOT = "https://assets.mcasset.cloud/1.17.1";
+var DEFAULT_ROOT = "https://assets.mcasset.cloud/1.21.11";
 var DEFAULT_NAMESPACE = "minecraft";
 var Assets = class {
   /**
@@ -1489,8 +1639,145 @@ var Assets = class {
 var AssetSource = class {
   constructor() {
   }
+  /**
+   * Identifies this source's content across sessions for persistent caching. Sources that
+   * cannot tell whether their content changed (an unnamed archive, for example) return
+   * undefined, which keeps their results out of long-lived caches.
+   */
+  get cacheId() {
+    return void 0;
+  }
+};
+var AssetLoadError = class extends Error {
+  constructor(source, key, path, cause) {
+    super(`Failed to load ${key.toNamespacedString()} from ${path}${cause instanceof Error ? `: ${cause.message}` : ""}`);
+    this.source = source;
+    this.key = key;
+    this.path = path;
+    this.cause = cause;
+    this.name = "AssetLoadError";
+  }
 };
 
+// src/util/BatchedExecutor.ts
+var BatchedExecutor = class {
+  constructor(interval = 1, batch = 30) {
+    this.interval = interval;
+    this.batch = batch;
+    this.queue = [];
+    this.task = setInterval(() => this.run());
+  }
+  submit(task) {
+    this.queue.push(task);
+  }
+  run() {
+    for (let i = 0; i < this.batch; i++) {
+      this.runNext();
+    }
+  }
+  runNext() {
+    let next = this.queue.shift();
+    if (next) next();
+  }
+};
+
+// src/util/model.ts
+var import_three8 = require("three");
+function applyElementRotation(rotation, geometry) {
+  const origin = new import_three8.Vector3(rotation.origin[0], rotation.origin[1], rotation.origin[2]);
+  geometry.translate(-origin.x, -origin.y, -origin.z);
+  switch (rotation.axis) {
+    case "x" /* X */:
+      geometry.rotateX(toRadians(rotation.angle));
+      break;
+    case "y" /* Y */:
+      geometry.rotateY(toRadians(rotation.angle));
+      break;
+    case "z" /* Z */:
+      geometry.rotateZ(toRadians(rotation.angle));
+      break;
+  }
+  if (rotation.rescale) {
+    if (Math.abs(rotation.angle) === 22.5) {
+      const s = 1 / Math.cos(0.39269909262657166);
+      geometry.scale(s, 1, s);
+    } else {
+      const s = 1 / Math.cos(0.7853981852531433);
+      geometry.scale(s, 1, s);
+    }
+  }
+  geometry.translate(origin.x, origin.y, origin.z);
+}
+function applyGenericRotation(axis, rotation, obj) {
+  switch (axis) {
+    case "x" /* X */:
+      obj.rotateOnAxis(new import_three8.Vector3(1, 0, 0), toRadians(rotation));
+      break;
+    case "y" /* Y */:
+      obj.rotateOnAxis(new import_three8.Vector3(0, 1, 0), toRadians(rotation));
+      break;
+    case "z" /* Z */:
+      obj.rotateOnAxis(new import_three8.Vector3(0, 0, 1), toRadians(rotation));
+      break;
+  }
+}
+function addBox3WireframeToObject(box, obj, color = 16777215, w = 2) {
+  let size = new import_three8.Vector3();
+  box.getSize(size);
+  let boxGeo = new import_three8.BoxGeometry(size.x, size.y, size.z, 1, 1, 1);
+  let wireGeo = new import_three8.EdgesGeometry(boxGeo);
+  let wireMat = new import_three8.LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new import_three8.LineSegments(wireGeo, wireMat);
+  obj.add(wireframe);
+  let axes = new import_three8.AxesHelper(1);
+  obj.add(axes);
+}
+function addWireframeToObject(obj, color = 16777215, w = 2) {
+  let boxGeo = new import_three8.BoxGeometry(16, 16, 16, 1, 1, 1);
+  let wireGeo = new import_three8.EdgesGeometry(boxGeo);
+  let wireMat = new import_three8.LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new import_three8.LineSegments(wireGeo, wireMat);
+  obj.add(wireframe);
+  let axes = new import_three8.AxesHelper(1);
+  obj.add(axes);
+}
+function addWireframeToMesh(geo, mesh, color = 16777215, w = 2) {
+  let wireGeo = new import_three8.EdgesGeometry(geo);
+  let wireMat = new import_three8.LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new import_three8.LineSegments(wireGeo, wireMat);
+  mesh.add(wireframe);
+  let axes = new import_three8.AxesHelper(1);
+  mesh.add(axes);
+}
+
+// src/util/performance.ts
+function captureException(e, ...extra) {
+  console.error(e, extra);
+}
+function timingStart(marker) {
+  console.time(marker);
+}
+function timingEnd(marker) {
+  console.timeEnd(marker);
+}
+
+// src/util/three.ts
+function isObject3D(obj) {
+  return obj.isObject3D;
+}
+function isMesh(obj) {
+  return obj.isMesh;
+}
+function isInstancedMesh(obj) {
+  return obj.isInstancedMesh;
+}
+function isPerspectiveCamera(obj) {
+  return obj.isPerspectiveCamera;
+}
+function isOrthographicCamera(obj) {
+  return obj.isOrthographicCamera;
+}
+
 // src/nbt/NBTHelper.ts
 var NBTHelper = class {
   static async fromBuffer(buffer) {
@@ -1506,7 +1793,83 @@ var p3 = prefix("HostedAssetSource");
 var DEFAULT_OPTIONS = {
   retryDefaults: true
 };
-var _HostedAssetSource = class _HostedAssetSource extends AssetSource {
+var HostedAssetSource = class _HostedAssetSource extends AssetSource {
+  static {
+    this.MODEL = {
+      config(request) {
+      },
+      parse(response) {
+        return response.data;
+      }
+    };
+  }
+  static {
+    this.BLOCKSTATE = {
+      config(request) {
+      },
+      parse(response) {
+        return response.data;
+      }
+    };
+  }
+  static {
+    this.META = {
+      config(request) {
+      },
+      parse(response) {
+        return response.data;
+      }
+    };
+  }
+  static {
+    this.NBT = {
+      config(request) {
+        request.responseType = "arraybuffer";
+      },
+      parse(response) {
+        return NBTHelper.fromBuffer(Buffer.from(response.data));
+      }
+    };
+  }
+  static {
+    this.IMAGE = {
+      config(request) {
+        request.responseType = "arraybuffer";
+      },
+      async parse(response) {
+        return await ImageLoader.processResponse(response);
+      }
+    };
+  }
+  static {
+    this.LIST = {
+      config(request) {
+      },
+      parse(response) {
+        return response.data;
+      }
+    };
+  }
+  static {
+    this.JSON = {
+      config(request) {
+      },
+      parse(response) {
+        return response.data;
+      }
+    };
+  }
+  static {
+    this.PARSER_MAP = /* @__PURE__ */ new Map([
+      ["model" /* MODEL */, _HostedAssetSource.MODEL],
+      ["blockstate" /* BLOCKSTATE */, _HostedAssetSource.BLOCKSTATE],
+      ["meta" /* META */, _HostedAssetSource.META],
+      ["nbt" /* NBT */, _HostedAssetSource.NBT],
+      ["image" /* IMAGE */, _HostedAssetSource.IMAGE],
+      ["list" /* LIST */, _HostedAssetSource.LIST],
+      ["json" /* JSON */, _HostedAssetSource.JSON]
+    ]);
+  }
   async loadOrRetryWithDefaults(key, parser) {
     const direct = await this.load(key, parser);
     if (typeof direct !== "undefined") {
@@ -1519,17 +1882,17 @@ var _HostedAssetSource = class _HostedAssetSource extends AssetSource {
       if (typeof namespaced !== "undefined") {
         return namespaced;
       }
-      if (typeof key.root !== "undefined" && key.root !== DEFAULT_ROOT || typeof this.root !== "undefined" && this.root !== DEFAULT_ROOT) {
+      if (typeof key.root !== "undefined" && key.root !== AssetLoader.ROOT || typeof this.root !== "undefined" && this.root !== AssetLoader.ROOT) {
         console.info(p3, "Retrying", key, "with default root+namespace");
-        const namespacedRootedKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, DEFAULT_ROOT);
+        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") {
           return namespacedRooted;
         }
       }
-    } else if (typeof key.root !== "undefined" && key.root !== DEFAULT_ROOT || typeof this.root !== "undefined" && this.root !== DEFAULT_ROOT) {
+    } else if (typeof key.root !== "undefined" && key.root !== AssetLoader.ROOT || typeof this.root !== "undefined" && this.root !== AssetLoader.ROOT) {
       console.info(p3, "Retrying", key, "with default root");
-      const rootKey = new AssetKey(key.namespace, key.path, key.assetType, key.type, key.rootType, key.extension, 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") {
         return rooted;
@@ -1541,31 +1904,25 @@ var _HostedAssetSource = class _HostedAssetSource extends AssetSource {
     console.info(p3, "Loading", key);
     const url = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
     console.debug(p3, url);
-    let req = {
-      url
-    };
-    parser.config(req);
-    return await Requests.mcAssetRequest(req).then((response) => {
-      if (response && response.data) {
-        try {
-          return parser.parse(response);
-        } catch (e) {
-          console.warn("Parser failed to process response", response, e);
-          throw e;
-        }
-      }
-      return void 0;
-    }).catch((err) => {
-      if (err.response) {
-        let response = err.response;
-        if (response.status === 404) {
-          console.debug(p3, key, "not found");
+    const request = { url };
+    try {
+      parser.config(request);
+      let response;
+      try {
+        response = await Requests.mcAssetRequest(request);
+      } catch (cause) {
+        if (cause instanceof RequestError && cause.response?.status === 404) {
           return void 0;
         }
+        throw cause;
       }
-      console.debug(p3, "Failed to load", key, err == null ? void 0 : err.message);
-      return void 0;
-    });
+      if (response.data === void 0) {
+        throw new Error("Asset response has no data");
+      }
+      return await parser.parse(response);
+    } catch (cause) {
+      throw new AssetLoadError(this, key, request.url, cause);
+    }
   }
   assetBasePath(key) {
     return `${key.root ?? this.root ?? AssetLoader.ROOT}/${key.rootType !== void 0 ? key.rootType + "/" : ""}${key.namespace !== void 0 ? key.namespace + "/" : ""}${key.assetType !== void 0 ? key.assetType + "/" : ""}`;
@@ -1578,6 +1935,9 @@ var _HostedAssetSource = class _HostedAssetSource extends AssetSource {
   get root() {
     return this._root;
   }
+  get cacheId() {
+    return `hosted:${this._root}`;
+  }
   get options() {
     return this._options;
   }
@@ -1589,74 +1949,14 @@ var _HostedAssetSource = class _HostedAssetSource extends AssetSource {
     return this.load(key, responseParser);
   }
 };
-_HostedAssetSource.MODEL = {
-  config(request) {
-  },
-  parse(response) {
-    return response.data;
-  }
-};
-_HostedAssetSource.BLOCKSTATE = {
-  config(request) {
-  },
-  parse(response) {
-    return response.data;
-  }
-};
-_HostedAssetSource.META = {
-  config(request) {
-  },
-  parse(response) {
-    return response.data;
-  }
-};
-_HostedAssetSource.NBT = {
-  config(request) {
-    request.responseType = "arraybuffer";
-  },
-  parse(response) {
-    return NBTHelper.fromBuffer(Buffer.from(response.data));
-  }
-};
-_HostedAssetSource.IMAGE = {
-  config(request) {
-    request.responseType = "arraybuffer";
-  },
-  async parse(response) {
-    return await ImageLoader.processResponse(response);
-  }
-};
-_HostedAssetSource.LIST = {
-  config(request) {
-  },
-  parse(response) {
-    return response.data;
-  }
-};
-_HostedAssetSource.JSON = {
-  config(request) {
-  },
-  parse(response) {
-    return response.data;
-  }
-};
-_HostedAssetSource.PARSER_MAP = /* @__PURE__ */ new Map([
-  ["model" /* MODEL */, _HostedAssetSource.MODEL],
-  ["blockstate" /* BLOCKSTATE */, _HostedAssetSource.BLOCKSTATE],
-  ["meta" /* META */, _HostedAssetSource.META],
-  ["nbt" /* NBT */, _HostedAssetSource.NBT],
-  ["image" /* IMAGE */, _HostedAssetSource.IMAGE],
-  ["list" /* LIST */, _HostedAssetSource.LIST],
-  ["json" /* JSON */, _HostedAssetSource.JSON]
-]);
-var HostedAssetSource = _HostedAssetSource;
 
 // src/assets/source/archive/BrowserArchiveProxy.ts
 var import_zip = require("@zip.js/zip.js");
 var BrowserArchiveProxy = class {
-  constructor(blob) {
+  constructor(blob, id) {
     this._blob = blob;
     this._reader = new import_zip.ZipReader(new import_zip.BlobReader(this._blob));
+    this.id = id ?? (typeof File !== "undefined" && blob instanceof File ? `${blob.name}:${blob.size}:${blob.lastModified}` : void 0);
   }
   async getEntries() {
     return (await this._reader.getEntries()).map((e) => {
@@ -1672,7 +1972,6 @@ var BrowserArchiveProxy = class {
 };
 
 // src/assets/source/archive/ArchiveAssetSource.ts
-var p4 = prefix("ArchiveAssetSource");
 var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
   constructor(archiveProxy) {
     super();
@@ -1682,6 +1981,10 @@ var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
   static blob(blob) {
     return new _ArchiveAssetSource(new BrowserArchiveProxy(blob));
   }
+  get cacheId() {
+    const id = this._archiveProxy.id;
+    return id === void 0 ? void 0 : `archive:${id}`;
+  }
   async getEntries() {
     return this._archiveProxy.getEntries();
   }
@@ -1691,74 +1994,31 @@ var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
   }
   async get(key, parser) {
     const responseParser = HostedAssetSource.PARSER_MAP.get(parser);
-    console.log("ArchiveAssetSource.get", key, parser);
-    let entries = await this.getEntries();
-    const path = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
-    console.log(path);
-    const entry = await this.getEntry(path);
-    console.log(entry);
-    if (!entry) {
-      return void 0;
-    }
-    let blob = await entry.getData();
-    const url = URL.createObjectURL(blob);
-    console.log(url);
-    let req = {
-      url
-    };
-    responseParser.config(req);
-    return Requests.genericRequest(req).then((response) => {
-      if (response && response.data) {
-        try {
-          return responseParser.parse(response);
-        } catch (e) {
-          console.warn("Parser failed to process response", response, e);
-          throw e;
-        }
-      }
-      return void 0;
-    }).catch((err) => {
-      if (err.response) {
-        let response = err.response;
-        if (response.status === 404) {
-          console.debug(p4, key, "not found");
-          return void 0;
-        }
-      }
-      console.debug(p4, "Failed to load", key, err == null ? void 0 : err.message);
-      return void 0;
-    });
+    return this.load(key, responseParser);
   }
-  //TODO: abstract this
   async load(key, parser) {
-    console.info(p4, "Loading", key);
-    const url = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
-    console.debug(p4, url);
-    let req = {
-      url
-    };
-    parser.config(req);
-    return await Requests.genericRequest(req).then((response) => {
-      if (response && response.data) {
-        try {
-          return parser.parse(response);
-        } catch (e) {
-          console.warn("Parser failed to process response", response, e);
-          throw e;
-        }
+    const path = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
+    let url;
+    try {
+      const entry = await this.getEntry(path);
+      if (!entry) {
+        return void 0;
       }
-      return void 0;
-    }).catch((err) => {
-      if (err.response) {
-        let response = err.response;
-        if (response.status === 404) {
-          console.debug(p4, key, "not found");
-          return void 0;
-        }
+      url = URL.createObjectURL(await entry.getData());
+      const request = { url };
+      parser.config(request);
+      const response = await Requests.genericRequest(request);
+      if (response.data === void 0) {
+        throw new Error("Asset response has no data");
       }
-      console.debug(p4, "Failed to load", key, err == null ? void 0 : err.message);
-      return void 0;
-    });
+      return await parser.parse(response);
+    } catch (cause) {
+      throw new AssetLoadError(this, key, path, cause);
+    } finally {
+      if (url !== void 0) {
+        URL.revokeObjectURL(url);
+      }
+    }
   }
   assetBasePath(key) {
     return `${key.rootType !== void 0 ? key.rootType + "/" : ""}${key.namespace !== void 0 ? key.namespace + "/" : ""}${key.assetType !== void 0 ? key.assetType + "/" : ""}`;
@@ -1766,18 +2026,64 @@ var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
 };
 
 // src/assets/AssetLoader.ts
-var import_ts_deepmerge3 = __toESM(require_dist());
-var p5 = prefix("AssetLoader");
-var _AssetLoader = class _AssetLoader {
+var p4 = prefix("AssetLoader");
+var FALLBACK_ROOT = "https://raw.githubusercontent.com/InventivetalentDev/minerender-fallback-assets/master";
+var AssetLoader = class {
+  static {
+    this.ROOT = DEFAULT_ROOT;
+  }
+  static {
+    this._SOURCES = [];
+  }
+  static {
+    /** Used when a registered source cannot identify its content, so nothing persists past this session. */
+    this.SESSION_SCOPE = `session:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+  }
+  static get version() {
+    return this.ROOT.substring(this.ROOT.lastIndexOf("/") + 1);
+  }
+  static setVersion(version) {
+    this.ROOT = `https://assets.mcasset.cloud/${version}`;
+    const source = new HostedAssetSource(this.ROOT, { retryDefaults: false });
+    const index = this._SOURCES.findIndex((s) => s.key === "mcassets");
+    if (index !== -1) {
+      this._SOURCES[index] = { key: "mcassets", source };
+    } else {
+      this.addSource("mcassets", source);
+    }
+    Caching.clear();
+  }
+  /**
+   * Scope for persistent cache keys. Empty with only the default vanilla sources, so their
+   * entries stay valid across sessions; otherwise it names every added source (resource packs,
+   * mirrors) so their results never masquerade as vanilla assets after a reload.
+   */
+  static get persistentScope() {
+    const parts = [];
+    for (const { key, source } of this._SOURCES) {
+      const id = source.cacheId;
+      if (key === "mcassets" && id === `hosted:${this.ROOT}`) continue;
+      if (key === "mcassets-fallback" && id === `hosted:${FALLBACK_ROOT}`) continue;
+      if (id === void 0) return this.SESSION_SCOPE;
+      parts.push(`${key}=${id}`);
+    }
+    return parts.join("|");
+  }
+  /** Prefixes a persistent cache key with the current source scope. */
+  static persistentKey(key) {
+    const scope = this.persistentScope;
+    return scope ? `${scope}
+${key}` : key;
+  }
   static addSource(key, source, override = true) {
     if (override) {
       const existing = this.removeSource(key);
       if (existing) {
-        console.log(p5, "Removed existing AssetSource", key);
+        console.log(p4, "Removed existing AssetSource", key);
       }
     }
     this._SOURCES.unshift({ key, source });
-    console.log(p5, "Added AssetSource", key);
+    console.log(p4, "Added AssetSource", key);
   }
   static removeSource(key) {
     const index = this._SOURCES.findIndex((s) => s.key === key);
@@ -1789,8 +2095,11 @@ var _AssetLoader = class _AssetLoader {
     }
     return void 0;
   }
+  static {
+    this.addSource("mcassets-fallback", new HostedAssetSource(FALLBACK_ROOT, { retryDefaults: false }));
+    this.addSource("mcassets", new HostedAssetSource(this.ROOT, { retryDefaults: false }));
+  }
   static async getAll(key, parser) {
-    console.log(this._SOURCES);
     let promises = [];
     for (const source of this._SOURCES) {
       promises.push(source.source.get(key, parser));
@@ -1799,31 +2108,36 @@ var _AssetLoader = class _AssetLoader {
       return results.filter((r) => r != void 0);
     });
   }
+  /** Returns the first defined result in source-priority order, without merging assets. */
   static async get(key, parser) {
-    console.log(this._SOURCES);
-    let promises = [];
-    for (const source of this._SOURCES) {
-      promises.push(source.source.get(key, parser));
-    }
-    return Promise.all(promises).then((results) => {
-      const fallback = results[results.length - 1];
-      for (const result of results) {
-        if (result) {
-          if (fallback) {
-            return (0, import_ts_deepmerge3.default)({}, fallback, result);
-          }
-          return result;
+    const keys = [key];
+    if (key.rootType === "data" && (key.assetType === "structure" || key.assetType === "structures")) {
+      keys.push(new AssetKey(
+        key.namespace,
+        key.path,
+        key.assetType === "structure" ? "structures" : "structure",
+        key.type,
+        key.rootType,
+        key.extension,
+        key.root
+      ));
+    }
+    return (await this.getFirst(keys, parser))?.asset;
+  }
+  /** Tries each path within a source before considering lower-priority sources. */
+  static async getFirst(keys, parser) {
+    const sources = [...this._SOURCES];
+    for (const source of sources) {
+      for (const key of keys) {
+        const result = await source.source.get(key, parser);
+        if (result !== void 0) {
+          return { key, asset: result };
         }
       }
-      return void 0;
-    });
+    }
+    return void 0;
   }
 };
-_AssetLoader.ROOT = DEFAULT_ROOT;
-_AssetLoader._SOURCES = [];
-_AssetLoader.addSource("mcassets-fallback", new HostedAssetSource("https://raw.githubusercontent.com/InventivetalentDev/minerender-fallback-assets/master", { retryDefaults: false }));
-_AssetLoader.addSource("mcassets", new HostedAssetSource(DEFAULT_ROOT, { retryDefaults: false }));
-var AssetLoader = _AssetLoader;
 
 // src/assets/ModelTextures.ts
 var ModelTextures = class {
@@ -1831,11 +2145,21 @@ var ModelTextures = class {
     return this._persistentMetaCache ??= PersistentCache.open("minerender-texturemeta");
   }
   static async get(key) {
-    const asset = await this.preload(key);
-    if (asset) {
-      return ImageLoader.infoToCanvasData(asset);
+    const keyStr = key.serialize();
+    const pending = this.preload(key);
+    const cached = Caching.textureAssetCache.getIfPresent(keyStr);
+    try {
+      const asset = await pending;
+      if (asset) {
+        return await ImageLoader.infoToCanvasData(asset);
+      }
+      return void 0;
+    } catch (err) {
+      if (cached && Caching.textureAssetCache.getIfPresent(keyStr) === cached) {
+        Caching.textureAssetCache.invalidate(keyStr);
+      }
+      throw err;
     }
-    return void 0;
   }
   static async preload(key) {
     const keyStr = key.serialize();
@@ -1854,7 +2178,7 @@ var ModelTextures = class {
     }
     const keyStr = key.serialize();
     return Caching.textureMetaCache.get(keyStr, (k) => {
-      return this.PERSISTENT_META_CACHE.getOrLoad(keyStr, (k1) => {
+      return this.PERSISTENT_META_CACHE.getOrLoad(AssetLoader.persistentKey(keyStr), (k1) => {
         return AssetLoader.get(key, "meta" /* META */).then((asset) => {
           if (asset)
             asset.key = key;
@@ -1909,7 +2233,28 @@ var CanvasImage = class {
 };
 
 // src/Ticker.ts
-var _Ticker = class _Ticker {
+var Ticker = class _Ticker {
+  static {
+    this.TPS = 20;
+  }
+  static {
+    this.counter = 0;
+  }
+  static {
+    this._tickers = /* @__PURE__ */ new Map();
+  }
+  static {
+    this.oneSecondTps = 0;
+  }
+  static {
+    this.oneSecondTicks = 0;
+  }
+  static {
+    this.fiveSecondTps = 0;
+  }
+  static {
+    this.fiveSecondTicks = 0;
+  }
   static schedule(fn, ms) {
     const handle = setInterval(fn, ms);
     const unref = handle.unref;
@@ -1971,14 +2316,6 @@ var _Ticker = class _Ticker {
     this._tickers.clear();
   }
 };
-_Ticker.TPS = 20;
-_Ticker.counter = 0;
-_Ticker._tickers = /* @__PURE__ */ new Map();
-_Ticker.oneSecondTps = 0;
-_Ticker.oneSecondTicks = 0;
-_Ticker.fiveSecondTps = 0;
-_Ticker.fiveSecondTicks = 0;
-var Ticker = _Ticker;
 
 // src/texture/TextureAtlas.ts
 var TextureAtlas = class {
@@ -2004,18 +2341,24 @@ var TextureAtlas = class {
 
 // src/model/ModelGenerator.ts
 var ModelGenerator = class {
+  static {
+    this.ITEM_LAYERS = ["layer0", "layer1", "layer2", "layer3", "layer4"];
+  }
   static generateItemModel(imageData, layer) {
+    const tintindex = this.ITEM_LAYERS.indexOf(layer);
     const mainElement = {
       from: [0, 0, 7.5],
       to: [16, 16, 8.5],
       faces: {
         "south": {
           uv: [0, 0, 16, 16],
-          texture: `#${layer}`
+          texture: `#${layer}`,
+          tintindex
         },
         "north": {
           uv: [16, 0, 0, 16],
-          texture: `#${layer}`
+          texture: `#${layer}`,
+          tintindex
         }
       },
       shade: true
@@ -2023,14 +2366,21 @@ var ModelGenerator = class {
     return [mainElement];
   }
 };
-ModelGenerator.ITEM_LAYERS = ["layer0", "layer1", "layer2", "layer3", "layer4"];
 
 // src/UVMapper.ts
-var p6 = prefix("UVMapper");
+var p5 = prefix("UVMapper");
 var DEFAULT_UV = [0, 0, 16, 16];
 var X = 0;
 var Y = 1;
 var Z = 2;
+var FACE_UV_AXES = {
+  east: [new import_three9.Vector3(0, 0, -1), new import_three9.Vector3(0, -1, 0)],
+  west: [new import_three9.Vector3(0, 0, 1), new import_three9.Vector3(0, -1, 0)],
+  up: [new import_three9.Vector3(1, 0, 0), new import_three9.Vector3(0, 0, 1)],
+  down: [new import_three9.Vector3(1, 0, 0), new import_three9.Vector3(0, 0, -1)],
+  south: [new import_three9.Vector3(1, 0, 0), new import_three9.Vector3(0, -1, 0)],
+  north: [new import_three9.Vector3(-1, 0, 0), new import_three9.Vector3(0, -1, 0)]
+};
 var UVMapper = class {
   static makeUv(uvCoord, originalTextureSize, actualTextureSize) {
     if (uvCoord === 0) return 0;
@@ -2126,7 +2476,43 @@ var UVMapper = class {
     return array;
   }
   static facesToUv(faces, originalTextureSize, actualTextureSize) {
-    return new import_three8.Float32BufferAttribute(this.facesToUvArray(faces, originalTextureSize, actualTextureSize), 2);
+    return new import_three9.Float32BufferAttribute(this.facesToUvArray(faces, originalTextureSize, actualTextureSize), 2);
+  }
+  static lockUvs(geometry, faces, atlas, rotation) {
+    const uv = geometry.getAttribute("uv");
+    for (let faceIndex = 0; faceIndex < CUBE_FACES.length; faceIndex++) {
+      const faceName = CUBE_FACES[faceIndex];
+      const texture = faces[faceName]?.texture?.substring(1);
+      const position = texture && atlas.positions[texture];
+      const size = texture && atlas.sizes[texture];
+      if (!position || !size) continue;
+      const [sourceU, sourceV] = FACE_UV_AXES[faceName];
+      const uAxis = sourceU.clone().applyEuler(rotation);
+      const vAxis = sourceV.clone().applyEuler(rotation);
+      const normal = vAxis.clone().cross(uAxis);
+      const targetFace = CUBE_FACES.find((name) => {
+        const [u, v] = FACE_UV_AXES[name];
+        return v.clone().cross(u).dot(normal) > 0.5;
+      });
+      const [targetU, targetV] = FACE_UV_AXES[targetFace];
+      const uu = Math.round(targetU.dot(uAxis));
+      const uvCross = Math.round(targetU.dot(vAxis));
+      const vu = Math.round(targetV.dot(uAxis));
+      const vv = Math.round(targetV.dot(vAxis));
+      for (let corner = 0; corner < 4; corner++) {
+        const index = faceIndex * 4 + corner;
+        const u = (uv.getX(index) * atlas.image.width - position[0]) / size[0] - 0.5;
+        const v = ((1 - uv.getY(index)) * atlas.image.height - position[1]) / size[1] - 0.5;
+        const lockedU = uu * u + uvCross * v + 0.5;
+        const lockedV = vu * u + vv * v + 0.5;
+        uv.setXY(
+          index,
+          (position[0] + lockedU * size[0]) / atlas.image.width,
+          1 - (position[1] + lockedV * size[1]) / atlas.image.height
+        );
+      }
+    }
+    uv.needsUpdate = true;
   }
   static async getAtlas(model) {
     const keyStr = model.key.serialize();
@@ -2168,43 +2554,42 @@ var UVMapper = class {
     v1 *= scaleV;
     u2 *= scaleU;
     v2 *= scaleV;
-    let tl = new import_three8.Vector2(u1, v1);
-    let tr = new import_three8.Vector2(u2, v1);
-    let bl = new import_three8.Vector2(u1, v2);
-    let br = new import_three8.Vector2(u2, v2);
+    let tl = new import_three9.Vector2(u1, v1);
+    let tr = new import_three9.Vector2(u2, v1);
+    let bl = new import_three9.Vector2(u1, v2);
+    let br = new import_three9.Vector2(u2, v2);
     switch (rotation) {
       case 0:
       case 360:
       default:
         break;
       case 90:
-        tl = new import_three8.Vector2(u1, v2);
-        tr = new import_three8.Vector2(u1, v1);
-        bl = new import_three8.Vector2(u2, v2);
-        br = new import_three8.Vector2(u2, v1);
+        tl = new import_three9.Vector2(u1, v2);
+        tr = new import_three9.Vector2(u1, v1);
+        bl = new import_three9.Vector2(u2, v2);
+        br = new import_three9.Vector2(u2, v1);
         break;
       case 180:
-        tl = new import_three8.Vector2(u2, v2);
-        tr = new import_three8.Vector2(u1, v2);
-        bl = new import_three8.Vector2(u2, v1);
-        br = new import_three8.Vector2(u1, v1);
+        tl = new import_three9.Vector2(u2, v2);
+        tr = new import_three9.Vector2(u1, v2);
+        bl = new import_three9.Vector2(u2, v1);
+        br = new import_three9.Vector2(u1, v1);
         break;
       case 270:
-        tl = new import_three8.Vector2(u2, v1);
-        tr = new import_three8.Vector2(u2, v2);
-        bl = new import_three8.Vector2(u1, v1);
-        br = new import_three8.Vector2(u1, v2);
+        tl = new import_three9.Vector2(u2, v1);
+        tr = new import_three9.Vector2(u2, v2);
+        bl = new import_three9.Vector2(u1, v1);
+        br = new import_three9.Vector2(u1, v2);
         break;
     }
     return [tl, tr, bl, br];
   }
   static async createAtlas(originalModel) {
-    var _a;
     const textureMap = {};
     const metaMap = {};
     const model = { ...originalModel };
     const isItemModel = !("elements" in model);
-    console.debug(p6, "Creating Atlas for", model.key);
+    console.debug(p5, "Creating Atlas for", model.key);
     if (model.textures) {
       const promises = [];
       const uniqueTextureNames = [];
@@ -2218,7 +2603,7 @@ var UVMapper = class {
           const assetKey = AssetKey.parse("textures", textureValue, model.key);
           promises.push(ModelTextures.get(assetKey).then((asset) => {
             if (!asset) {
-              console.warn(p6, "Missing texture", assetKey);
+              console.warn(p5, "Missing texture", assetKey);
               return;
             }
             textureMap[textureKey] = new WrappedImage(asset);
@@ -2230,7 +2615,7 @@ var UVMapper = class {
       }
       await Promise.all(promises);
       const textureCount = uniqueTextureNames.length;
-      console.debug(p6, "Creating Atlas for", textureCount, "textures");
+      console.debug(p5, "Creating Atlas for", textureCount, "textures");
       this.fillMissingTextureKeys(model.textures, textureMap);
       this.fillMissingTextureKeys(model.textures, metaMap);
       const sizes = {};
@@ -2250,7 +2635,7 @@ var UVMapper = class {
       this.fillMissingTextureKeys(model.textures, sizes);
       const s = Math.ceil(Math.sqrt(textureCount + 1));
       const size = Math.ceil(s * maxWidth);
-      console.debug(p6, "Atlas size:", size);
+      console.debug(p5, "Atlas size:", size);
       const squaredSize = size * size;
       const missing = await ImageLoader.getData("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABAAQMAAACQp+OdAAAABlBMVEX/AP8AAACfphTyAAAAFUlEQVQoz2MIhQKGVVAwKjIqQrwIAHRz/wFI17TEAAAAAElFTkSuQmCC");
       const empty = await ImageLoader.getData("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABAAQMAAACQp+OdAAAAA1BMVEUAAACnej3aAAAAAXRSTlMAQObYZgAAAA5JREFUKM9jGAWjgAIAAAJAAAFSSwuTAAAAAElFTkSuQmCC");
@@ -2279,16 +2664,15 @@ var UVMapper = class {
           if (texture.animated) {
             hasAnimation = true;
             const meta = metaMap[textureKey];
-            const frameTime = ((_a = meta == null ? void 0 : meta.animation) == null ? void 0 : _a.frametime) ?? 1;
+            const frameTime = meta?.animation?.frametime ?? 1;
             console.log(meta);
             console.log(frameTime);
             let t = 0;
             let f = 0;
             animatorFunctions[textureKey] = () => {
-              var _a2;
               if (t++ >= frameTime) {
                 t = 0;
-                const frames = (_a2 = meta == null ? void 0 : meta.animation) == null ? void 0 : _a2.frames;
+                const frames = meta?.animation?.frames;
                 const frame = frames ? frames[f] : f;
                 image.putData(texture.getFrameSectionData(frame), x, y, 0, 0, maxWidth, maxWidth);
                 f++;
@@ -2306,10 +2690,10 @@ var UVMapper = class {
         }
       }
       const atlasImageData = image.toDataURL();
-      console.log(p6, "Atlas Image for", model.key, atlasImageData);
+      console.log(p5, "Atlas Image for", model.key, atlasImageData);
       this.fillMissingTextureKeys(model.textures, positions);
       if (isItemModel) {
-        console.debug(p6, "Generating item model for", model);
+        console.debug(p5, "Generating item model for", model);
         model.elements = [];
         for (let layerName of ModelGenerator.ITEM_LAYERS) {
           const textureImage = textureMap[layerName];
@@ -2317,7 +2701,7 @@ var UVMapper = class {
             model.elements.push(...ModelGenerator.generateItemModel(textureImage.data, layerName));
           }
         }
-        console.debug(p6, "Item model elements", model.elements);
+        console.debug(p5, "Item model elements", model.elements);
       }
       if (!model.elements) {
       }
@@ -2335,18 +2719,14 @@ var UVMapper = class {
               this.setCubeFaceUvInArray(uv, faceIndex * 4, [0, 1, 8 / size, (size - 8) / size]);
               continue;
             }
+            if (!face.texture) continue;
             if (!face.uv) {
               face.uv = this.getFallbackUv(element, faceName);
             }
-            let faceTexture = face.texture;
-            let texPosition;
-            let texSize;
-            if (faceTexture) {
-              faceTexture = faceTexture.substr(1);
-              texPosition = positions[faceTexture] || [0, 0];
-              texSize = sizes[faceTexture] || [16, 16];
-            }
-            let texPosV = new import_three8.Vector2(texPosition[0], texPosition[1]);
+            const faceTexture = face.texture.substr(1);
+            const texPosition = positions[faceTexture] || [0, 0];
+            const texSize = sizes[faceTexture] || [16, 16];
+            let texPosV = new import_three9.Vector2(texPosition[0], texPosition[1]);
             const [tl, tr, bl, br] = this.expandAndRotateMcUvs(face.uv, face.rotation, texSize[0], texSize[1]);
             tl.add(texPosV);
             tr.add(texPosV);
@@ -2377,7 +2757,7 @@ var UVMapper = class {
         hasTransparency
       );
     } else {
-      console.warn(p6, "Model does not have any textures", model);
+      console.warn(p5, "Model does not have any textures", model);
     }
     return void 0;
   }
@@ -2419,18 +2799,18 @@ var MinecraftCubeTexture = class {
   }
   getUvEast(w, h, l) {
     return [
-      [this.mapW(this.u), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l), this.mapH(this.v + l + h)],
-      [this.mapW(this.u), this.mapH(this.v + l)],
-      [this.mapW(this.u + l), this.mapH(this.v + l)]
+      [this.mapW(this.u + l + w + l), this.mapH(this.v + l + h)],
+      [this.mapW(this.u + l + w), this.mapH(this.v + l + h)],
+      [this.mapW(this.u + l + w + l), this.mapH(this.v + l)],
+      [this.mapW(this.u + l + w), this.mapH(this.v + l)]
     ];
   }
   getUvWest(w, h, l) {
     return [
-      [this.mapW(this.u + l + w), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l + w + l), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l + w), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w + l), this.mapH(this.v + l)]
+      [this.mapW(this.u + l), this.mapH(this.v + l + h)],
+      [this.mapW(this.u), this.mapH(this.v + l + h)],
+      [this.mapW(this.u + l), this.mapH(this.v + l)],
+      [this.mapW(this.u), this.mapH(this.v + l)]
     ];
   }
   getUvUp(w, h, l) {
@@ -2443,26 +2823,26 @@ var MinecraftCubeTexture = class {
   }
   getUvDown(w, h, l) {
     return [
-      [this.mapW(this.u + l), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w), this.mapH(this.v + l)],
       [this.mapW(this.u + l), this.mapH(this.v)],
-      [this.mapW(this.u + l + w), this.mapH(this.v)]
+      [this.mapW(this.u + l + w), this.mapH(this.v)],
+      [this.mapW(this.u + l), this.mapH(this.v + l)],
+      [this.mapW(this.u + l + w), this.mapH(this.v + l)]
     ];
   }
   getUvSouth(w, h, l) {
     return [
-      [this.mapW(this.u + l + w + l), this.mapH(this.v + l + h)],
       [this.mapW(this.u + l + w + l + w), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l + w + l), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w + l + w), this.mapH(this.v + l)]
+      [this.mapW(this.u + l + w + l), this.mapH(this.v + l + h)],
+      [this.mapW(this.u + l + w + l + w), this.mapH(this.v + l)],
+      [this.mapW(this.u + l + w + l), this.mapH(this.v + l)]
     ];
   }
   getUvNorth(w, h, l) {
     return [
-      [this.mapW(this.u + l), this.mapH(this.v + l + h)],
       [this.mapW(this.u + l + w), this.mapH(this.v + l + h)],
-      [this.mapW(this.u + l), this.mapH(this.v + l)],
-      [this.mapW(this.u + l + w), this.mapH(this.v + l)]
+      [this.mapW(this.u + l), this.mapH(this.v + l + h)],
+      [this.mapW(this.u + l + w), this.mapH(this.v + l)],
+      [this.mapW(this.u + l), this.mapH(this.v + l)]
     ];
   }
   getFaceUv(face, w, h, l) {
@@ -2481,10 +2861,12 @@ var MinecraftCubeTexture = class {
         return this.getUvNorth(w, h, l);
     }
   }
-  toUvArray(w, h, l) {
+  toUvArray(w, h, l, mirror = false) {
     const uv = [];
     for (let i = 0; i < CUBE_FACES.length; i++) {
-      UVMapper.setFaceUvInArray(uv, i * 4, this.getFaceUv(CUBE_FACES[i], w, h, l));
+      const face = mirror && i < 2 ? CUBE_FACES[1 - i] : CUBE_FACES[i];
+      const corners = this.getFaceUv(face, w, h, l);
+      UVMapper.setFaceUvInArray(uv, i * 4, mirror ? [corners[1], corners[0], corners[3], corners[2]] : corners);
     }
     return uv;
   }
@@ -2514,76 +2896,85 @@ function shutdown() {
   Caching.end();
 }
 
+// src/error/MineRenderError.ts
+var MineRenderError = class _MineRenderError extends Error {
+  constructor(msg) {
+    super(msg);
+    Object.setPrototypeOf(this, _MineRenderError.prototype);
+  }
+  get name() {
+    return "MineRenderError";
+  }
+};
+
 // src/assets/Entities.ts
-var import_typescript_memoize3 = require("typescript-memoize");
 var Entities = class {
-  static async getBlockEntityModels() {
-    const key = AssetKey.parse("models", "minerender:blockEntityModels");
-    console.log(key);
-    return AssetLoader.get(key, "json" /* JSON */);
-  }
-  static async getEntityModels() {
-    const key = AssetKey.parse("models", "minerender:entityModels");
-    console.log(key);
-    return AssetLoader.get(key, "json" /* JSON */);
-  }
-  // BlockEntity names are hardcoded
-  static async getBlockList() {
-    const models = await this.getBlockEntityModels();
-    if (!models) {
-      return [];
-    }
-    return Object.keys(models);
-  }
   static async getEntityList() {
-    const models = await this.getEntityModels();
-    if (!models) {
-      return [];
-    }
-    return Object.keys(models);
-  }
-  static async getBlock(modelKey, textureKey) {
-    const models = await this.getBlockEntityModels();
-    if (!models) {
-      return void 0;
-    }
-    if (!textureKey) {
-      textureKey = modelKey;
-    }
-    const baseKey = modelKey.path.includes("/") ? new BasicAssetKey(modelKey.namespace, modelKey.path.split("/")[0]) : modelKey;
-    return {
-      key: textureKey,
-      parts: models[baseKey.toNamespacedString()]
+    const collect = async (path) => {
+      const prefix2 = path ? `${path}/` : "";
+      const key = new AssetKey(DEFAULT_NAMESPACE, `${prefix2}_list`, void 0, void 0, "entity-models", ".json");
+      const list = await Caching.listAssetCache.get(key.serialize(), () => AssetLoader.get(key, "list" /* LIST */));
+      if (!list) return [];
+      const files = list.files.filter((file) => file.endsWith(".json") && file !== "_list.json").map((file) => `${prefix2}${file.slice(0, -5)}`);
+      const children = await Promise.all(list.directories.map((directory) => collect(`${prefix2}${directory}`)));
+      return [...files, ...children.flat()];
     };
+    return collect("");
+  }
+  static async getEntity(modelKey, textureKey, options) {
+    const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
+    const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json");
+    const model = await Caching.entityModelCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+    if (!model) return void 0;
+    const layerName = options?.layer ?? "main";
+    const layer = model.layers[layerName];
+    if (!layer) {
+      throw new MineRenderError(`Entity ${model.id} has no layer "${layerName}". Available layers: ${Object.keys(model.layers).join(", ")}`);
+    }
+    let texture;
+    if (textureKey) {
+      const path2 = isAssetKey(textureKey) ? textureKey.getFullPath() : textureKey.path;
+      texture = isAssetKey(textureKey) && textureKey.assetType === "textures" && path2.startsWith("entity/") ? textureKey : new AssetKey(textureKey.namespace, path2, "textures", "entity", "assets", ".png", isAssetKey(textureKey) ? textureKey.root : void 0);
+    } else if (layer.textureLocation !== void 0) {
+      texture = AssetKey.parse("textures", layer.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+    } else {
+      texture = await this.resolveTexture(modelKey);
+    }
+    return { key: textureKey ?? modelKey, texture, layer, id: model.id };
+  }
+  static async resolveTexture(modelKey) {
+    const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
+    const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models", ".json");
+    return Caching.entityTextureCache.get(key.serialize(), async () => {
+      const name = path.split("/").pop();
+      for (const candidate of [path, `${path}/${name}`]) {
+        const texture = new AssetKey(modelKey.namespace, candidate, "textures", "entity", "assets", ".png");
+        if (await ModelTextures.get(texture)) return texture;
+      }
+      const listKey = new AssetKey(modelKey.namespace, "_list", `${name}_variant`, void 0, "data", ".json");
+      const list = await AssetLoader.get(listKey, "list" /* LIST */);
+      const files = list?.files.filter((file2) => file2.endsWith(".json") && file2 !== "_list.json");
+      const file = files?.find((file2) => file2 === "temperate.json") ?? files?.[0];
+      if (!file) return void 0;
+      const variantKey = new AssetKey(modelKey.namespace, file.slice(0, -5), `${name}_variant`, void 0, "data", ".json");
+      const variant = await AssetLoader.get(variantKey, "json" /* JSON */);
+      const assets = variant?.assets;
+      const textureId = variant?.asset_id ?? (typeof assets?.wild === "string" ? assets.wild : Object.values(assets ?? {}).find((value) => typeof value === "string"));
+      return typeof textureId === "string" ? AssetKey.parse("textures", textureId) : void 0;
+    });
   }
-  static async getEntity(modelKey, textureKey) {
-    const models = await this.getEntityModels();
-    if (!models) {
-      return void 0;
-    }
-    if (!textureKey) {
-      textureKey = modelKey;
-    }
-    const baseKey = modelKey.path.includes("/") ? new BasicAssetKey(modelKey.namespace, modelKey.path.split("/")[0]) : modelKey;
-    return {
-      key: textureKey,
-      parts: models[baseKey.toNamespacedString()]
-    };
+  /** @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);
   }
-};
-__decorateClass([
-  (0, import_typescript_memoize3.Memoize)()
-], Entities, "getBlockEntityModels", 1);
-__decorateClass([
-  (0, import_typescript_memoize3.Memoize)()
-], Entities, "getEntityModels", 1);
-var EntityModels = class {
-};
-var BlockEntityModels = class {
 };
 
 // src/renderer/SceneObject.ts
-var import_three9 = require("three");
+var import_three10 = require("three");
 
 // src/instance/InstanceReference.ts
 var InstanceReference = class {
@@ -2628,30 +3019,27 @@ function isInstanceReference(obj) {
   return obj.isInstanceReference;
 }
 
-// src/error/MineRenderError.ts
-var MineRenderError = class _MineRenderError extends Error {
-  constructor(msg) {
-    super(msg);
-    Object.setPrototypeOf(this, _MineRenderError.prototype);
-  }
-  get name() {
-    return "MineRenderError";
-  }
-};
-
 // src/renderer/SceneObject.ts
-var import_ts_deepmerge4 = __toESM(require_dist());
-var p7 = prefix("SceneObject");
-var _SceneObject = class _SceneObject extends import_three9.Object3D {
+var import_ts_deepmerge3 = __toESM(require_dist());
+var p6 = prefix("SceneObject");
+var SceneObject = class _SceneObject extends import_three10.Object3D {
   constructor(options) {
     super();
     this.isSceneObject = true;
     this.materialCallbacks = {};
     this._isInstanced = false;
     this._instanceCounter = 0;
-    this.options = (0, import_ts_deepmerge4.default)({}, _SceneObject.DEFAULT_OPTIONS, options ?? {});
+    this.options = (0, import_ts_deepmerge3.default)({}, _SceneObject.DEFAULT_OPTIONS, options ?? {});
     console.log("SceneObject options", this.options);
   }
+  static {
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge3.default)({}, {
+      instanceMeshes: true,
+      maxInstanceCount: 50,
+      mergeMeshes: true,
+      wireframe: false
+    });
+  }
   set scene(scene) {
     if (!!this._scene) throw new MineRenderError("Scene already set");
     this._scene = scene;
@@ -2680,7 +3068,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     return group;
   }
   createGroup(name, x = 0, y = 0, z = 0, offsetAxis, offset = 0) {
-    const obj = new import_three9.Object3D();
+    const obj = new import_three10.Object3D();
     if (name) {
       obj.name = `group:${name}`;
     }
@@ -2730,7 +3118,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     return mesh;
   }
   createMesh(name, geometry, material, offsetAxis, offset = 0) {
-    const mesh = new import_three9.Mesh(geometry, material);
+    const mesh = new import_three10.Mesh(geometry, material);
     if (name) {
       mesh.name = `mesh:${name}`;
     }
@@ -2742,7 +3130,8 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     return mesh;
   }
   createInstancedMesh(name, geometry, material, count) {
-    const mesh = new import_three9.InstancedMesh(geometry, material, count);
+    const mesh = new import_three10.InstancedMesh(geometry, material, count);
+    mesh.count = 0;
     if (name) {
       mesh.name = `mesh:${name}`;
     }
@@ -2763,15 +3152,8 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     return this.toggleObjectVisibility(this.getMeshByName(name), visible);
   }
   iterateAllMeshes(cb) {
-    this.children.forEach((obj) => {
-      if (obj.isMesh) {
-        cb(obj);
-      }
-      obj.children.forEach((obj1) => {
-        if (obj1.isMesh) {
-          cb(obj1);
-        }
-      });
+    this.traverse((obj) => {
+      if (isMesh(obj)) cb(obj);
     });
   }
   //</editor-fold>
@@ -2819,10 +3201,14 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
   nextInstance() {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const i = this._instanceCounter++;
-    this.setMatrixAt(i, new import_three9.Matrix4());
-    console.debug(p7, "nextInstance " + i);
+    this.setMatrixAt(i, new import_three10.Matrix4());
+    const mesh = this.children[0];
+    if (mesh && isInstancedMesh(mesh)) {
+      mesh.count = Math.min(this._instanceCounter, mesh.instanceMatrix.count);
+    }
+    console.debug(p6, "nextInstance " + i);
     if (i === this.options.maxInstanceCount) {
-      console.warn(p7, "Max instance count reached for " + this);
+      console.warn(p6, "Max instance count reached for " + this);
     }
     if (this.scene) {
       this.scene.stats.instanceCount++;
@@ -2832,7 +3218,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
   }
   //</editor-fold>
   //<editor-fold desc="TRANSFORMATION">
-  getMatrixAt(index, matrix = new import_three9.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three10.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this.children[0];
     if (child && isInstancedMesh(child)) {
@@ -2851,16 +3237,16 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
   }
   setPositionRotationScaleAt(index, position, rotation, scale) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-    const oldPosition = new import_three9.Vector3();
-    const oldRotation = new import_three9.Quaternion();
-    const oldScale = new import_three9.Vector3();
-    const matrix = new import_three9.Matrix4();
+    const oldPosition = new import_three10.Vector3();
+    const oldRotation = new import_three10.Quaternion();
+    const oldScale = new import_three10.Vector3();
+    const matrix = new import_three10.Matrix4();
     if (!scale || !rotation || !position) {
       this.getMatrixAt(index, matrix).decompose(oldPosition, oldRotation, oldScale);
     }
     matrix.compose(
       position ? position : oldPosition,
-      rotation ? new import_three9.Quaternion().setFromEuler(rotation) : oldRotation,
+      rotation ? new import_three10.Quaternion().setFromEuler(rotation) : oldRotation,
       scale ? scale : oldScale
     );
     this.setMatrixAt(index, matrix);
@@ -2869,7 +3255,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     this.setPositionRotationScaleAt(index, position);
   }
-  getPositionAt(index, vector = new import_three9.Vector3()) {
+  getPositionAt(index, vector = new import_three10.Vector3()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const matrix = this.getMatrixAt(index);
     vector.setFromMatrixPosition(matrix);
@@ -2879,7 +3265,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     this.setPositionRotationScaleAt(index, void 0, rotation, void 0);
   }
-  getRotationAt(index, euler = new import_three9.Euler()) {
+  getRotationAt(index, euler = new import_three10.Euler()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const matrix = this.getMatrixAt(index);
     euler.setFromRotationMatrix(matrix);
@@ -2889,7 +3275,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     this.setPositionRotationScaleAt(index, void 0, void 0, scale);
   }
-  getScaleAt(index, vector = new import_three9.Vector3()) {
+  getScaleAt(index, vector = new import_three10.Vector3()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const matrix = this.getMatrixAt(index);
     vector.setFromMatrixScale(matrix);
@@ -2993,34 +3379,28 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     this.notifyDirty();
   }
   removeFromScene() {
-    var _a;
-    (_a = this._scene) == null ? void 0 : _a.remove(this);
+    this._scene?.remove(this);
     this.notifyDirty();
   }
   //</editor-fold>
 };
-_SceneObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, {
-  instanceMeshes: true,
-  maxInstanceCount: 50,
-  mergeMeshes: true,
-  wireframe: false
-});
-var SceneObject = _SceneObject;
 function isSceneObject(obj) {
   return obj.isSceneObject;
 }
 
 // src/entity/scene/EntityObject.ts
-var import_ts_deepmerge5 = __toESM(require_dist());
-var import_three11 = require("three");
-var THREE2 = __toESM(require("three"));
-var EntityObject = class extends SceneObject {
+var import_ts_deepmerge4 = __toESM(require_dist());
+var import_three12 = require("three");
+var EntityObject = class _EntityObject extends SceneObject {
   constructor(entity, options) {
     super();
     this.entity = entity;
     this.isEntityObject = true;
     this.meshesCreated = false;
-    this.options = (0, import_ts_deepmerge5.default)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
+    this.options = (0, import_ts_deepmerge4.default)({}, _EntityObject.DEFAULT_OPTIONS, options ?? {});
+  }
+  static {
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS, { flip: true });
   }
   async init() {
     this.createMeshes();
@@ -3029,67 +3409,76 @@ var EntityObject = class extends SceneObject {
   dispose() {
     super.dispose();
   }
-  async loadTextures() {
-    var _a;
-    this.imageData = await ModelTextures.get(new AssetKey(
-      ((_a = this.entity.key) == null ? void 0 : _a.namespace) ?? DEFAULT_NAMESPACE,
-      this.entity.key.path,
-      //TODO: texture may differ from entity name; most of them are in subdirectories for multiple variants etc.
+  get textureKey() {
+    if (this.entity.texture) return this.entity.texture;
+    const key = this.entity.key;
+    return new AssetKey(
+      key.namespace,
+      isAssetKey(key) ? key.getFullPath() : key.path,
       "textures",
       "entity",
       "assets",
       ".png"
-    ));
+    );
+  }
+  async loadTextures() {
+    this.imageData = await ModelTextures.get(this.textureKey);
   }
-  //TODO: abstract this, since extracted model data can be used for entities, blocks, players
   createMeshes(force = false) {
     if (this.meshesCreated && !force) return;
-    const mat = Materials.MISSING_TEXTURE;
-    for (let partName in this.entity.parts) {
-      const part = this.entity.parts[partName];
-      const texture = new MinecraftCubeTexture(part.textureOffsetU, part.textureOffsetV, part.textureWidth, part.textureHeight);
-      const partAnchor = new import_three11.Object3D();
-      partAnchor.position.x = part.pivotX;
-      partAnchor.position.y = part.pivotY;
-      partAnchor.position.z = part.pivotZ;
-      for (let cube of part.cubes) {
-        const w = cube.maxX - cube.minX;
-        const h = cube.maxY - cube.minY;
-        const l = cube.maxZ - cube.minZ;
-        const uv = texture.toUvArray(w, h, l);
-        const cubeGeo = this._getBoxGeometryForDimensionsAndUv(w, h, l, uv).clone();
-        cubeGeo.applyMatrix4(new THREE2.Matrix4().makeTranslation(w / 2, h / 2, l / 2));
-        cubeGeo.applyMatrix4(new THREE2.Matrix4().makeTranslation(cube.minX, cube.minY, cube.minZ));
-        applyModelPartRotation(part, cubeGeo);
-        const mesh = this.createMesh(partName, cubeGeo, mat);
-        partAnchor.add(mesh);
-        if (this.options.wireframe) {
-          addWireframeToMesh(cubeGeo, mesh);
-        }
-      }
-      this.add(partAnchor);
-    }
+    const modelRoot = new import_three12.Object3D();
+    if (this.options.flip) modelRoot.scale.set(-1, -1, 1);
+    this.add(modelRoot);
+    this.createPart("root", this.entity.layer.root, modelRoot, this.entity.layer.texture, Materials.MISSING_TEXTURE);
     this.meshesCreated = true;
   }
-  async applyTextures() {
-    var _a;
-    const textureAsset = await ModelTextures.preload(new AssetKey(
-      ((_a = this.entity.key) == null ? void 0 : _a.namespace) ?? DEFAULT_NAMESPACE,
-      this.entity.key.path,
-      "textures",
-      "entity",
-      "assets",
-      ".png"
-    ));
-    if (textureAsset) {
-      let mat = Materials.getImage({ texture: { src: textureAsset.src } });
-      this.iterateAllMeshes((mesh) => {
-        mesh.material = mat;
-      });
+  createPart(name, part, parent, textureSize, material) {
+    const anchor = this.createGroup(name);
+    anchor.position.fromArray(part.pose.offset);
+    anchor.rotation.set(...part.pose.rotation, "ZYX");
+    anchor.scale.fromArray(part.pose.scale ?? [1, 1, 1]);
+    parent.add(anchor);
+    const size = part.texture ?? textureSize;
+    for (const cube of part.cubes) {
+      const [width, height, depth] = cube.size;
+      const [growX, growY, growZ] = cube.grow ?? [0, 0, 0];
+      const texture = new MinecraftCubeTexture(...cube.uv, ...size);
+      const uv = size[0] === 0 || size[1] === 0 ? new Array(48).fill(0) : texture.toUvArray(width, height, depth, cube.mirror);
+      const geometry = this._getBoxGeometryForDimensionsAndUv(
+        width + growX * 2,
+        height + growY * 2,
+        depth + growZ * 2,
+        uv
+      ).clone();
+      geometry.translate(cube.origin[0] + width / 2, cube.origin[1] + height / 2, cube.origin[2] + depth / 2);
+      const mesh = this.createMesh(name, geometry, material);
+      anchor.add(mesh);
+      if (this.options.wireframe) addWireframeToMesh(geometry, mesh);
+    }
+    for (const [childName, child] of Object.entries(part.children)) {
+      this.createPart(childName, child, anchor, size, material);
     }
   }
+  async applyTextures() {
+    const assetKeyStr = this.textureKey.serialize();
+    const keyStr = `entity:${assetKeyStr}`;
+    let mat = Caching.materialCache.getIfPresent(keyStr);
+    if (!mat) {
+      const pending = this.loadTextures();
+      const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
+      await pending;
+      if (!this.imageData) return;
+      const canvas = this.imageData.data.canvas;
+      const createMaterial = () => Materials.createBasicCanvasMaterial(canvas);
+      mat = cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
+      this.imageData = void 0;
+    }
+    this.iterateAllMeshes((mesh) => {
+      mesh.material = mat;
+    });
+    this.notifyDirty();
+  }
 };
-EntityObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge5.default)({}, SceneObject.DEFAULT_OPTIONS, {});
 function isEntityObject(obj) {
   return obj.isEntityObject;
 }
@@ -3100,16 +3489,16 @@ var GuiObject = class extends SceneObject {
 };
 
 // src/inspector/SceneInspector.ts
-var import_three12 = require("three");
-var p8 = prefix("SceneInspector");
+var import_three13 = require("three");
+var p7 = prefix("SceneInspector");
 var help = "<span>Ctrl+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
-    this.mouse = new import_three12.Vector2();
+    this.mouse = new import_three13.Vector2();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
-    this.raycaster = new import_three12.Raycaster();
+    this.raycaster = new import_three13.Raycaster();
     this.init();
   }
   init() {
@@ -3130,8 +3519,7 @@ var SceneInspector = class {
     return out;
   }
   onClick(event) {
-    var _a;
-    if (((_a = event.target) == null ? void 0 : _a.nodeName) !== "CANVAS") return;
+    if (event.target?.nodeName !== "CANVAS") return;
     if (!event.ctrlKey) return;
     setTimeout(() => {
       this.mouse.x = event.clientX / window.innerWidth * 2 - 1;
@@ -3171,7 +3559,7 @@ var SceneInspector = class {
   }
   selectObject(targetObject, targetIntersection) {
     this.selectedObject = targetObject;
-    console.log(p8, "selected", targetObject);
+    console.log(p7, "selected", targetObject);
     this.redraw(targetObject, targetIntersection);
   }
   redraw(targetObject, targetIntersection) {
@@ -3469,7 +3857,7 @@ var SceneStatsDisplay = class {
 };
 
 // src/instance/InstanceManager.ts
-var p9 = prefix("InstanceManager");
+var p8 = prefix("InstanceManager");
 var InstanceManager = class {
   constructor() {
     this.isInstanceManager = true;
@@ -3477,7 +3865,7 @@ var InstanceManager = class {
   }
   async get(key) {
     if (key in this.instanceCache) {
-      console.debug(p9, "key in cache", key);
+      console.debug(p8, "key in cache", key);
       return (await this.instanceCache[key]).nextInstance();
     }
     return void 0;
@@ -3486,13 +3874,17 @@ var InstanceManager = class {
     if (key in this.instanceCache) {
       return await this.get(key);
     }
-    console.debug(p9, "key not in cache", key);
-    this.instanceCache[key] = new Promise(async (resolve) => {
-      const obj = await supplier();
-      const instance = obj.nextInstance();
-      resolve(instance);
-    });
-    return await this.instanceCache[key];
+    console.debug(p8, "key not in cache", key);
+    const pending = Promise.resolve().then(supplier).then((obj) => obj.nextInstance());
+    this.instanceCache[key] = pending;
+    try {
+      return await pending;
+    } catch (error) {
+      if (this.instanceCache[key] === pending) {
+        delete this.instanceCache[key];
+      }
+      throw error;
+    }
   }
   reset() {
     for (let instanceCacheKey in this.instanceCache) {
@@ -3509,20 +3901,6 @@ function isInstanceable(obj) {
   return "nextInstance" in obj;
 }
 
-// src/model/DisplayPosition.ts
-var DisplayPosition = /* @__PURE__ */ ((DisplayPosition2) => {
-  DisplayPosition2["THIRDPERSON_RIGHTHAND"] = "thirdperson_righthand";
-  DisplayPosition2["THIRDPERSON_LEFTHAND"] = "thirdperson_lefthand";
-  DisplayPosition2["FIRSTPERSON_RIGHTHAND"] = "firstperson_righthand";
-  DisplayPosition2["FIRSTPERSON_LEFTHAND"] = "firstperson_lefthand";
-  DisplayPosition2["GUI"] = "gui";
-  DisplayPosition2["HEAD"] = "head";
-  DisplayPosition2["GROUND"] = "ground";
-  DisplayPosition2["FIXED"] = "fixed";
-  return DisplayPosition2;
-})(DisplayPosition || {});
-var DISPLAY_POSITIONS = Object.values(DisplayPosition);
-
 // src/model/GuiLight.ts
 var GuiLight = /* @__PURE__ */ ((GuiLight2) => {
   GuiLight2["FRONT"] = "front";
@@ -3545,11 +3923,96 @@ function isQuadArray(obj) {
   return Array.isArray(obj) && obj.length === 4;
 }
 
+// src/model/block/blockTints.json
+var blockTints_default = {
+  "minecraft:large_fern": { source: "grass" },
+  "minecraft:tall_grass": { source: "grass" },
+  "minecraft:grass_block": { source: "grass" },
+  "minecraft:fern": { source: "grass" },
+  "minecraft:grass": { source: "grass" },
+  "minecraft:short_grass": { source: "grass" },
+  "minecraft:potted_fern": { source: "grass" },
+  "minecraft:bush": { source: "grass" },
+  "minecraft:pink_petals": { source: "grass", untinted: [0] },
+  "minecraft:wildflowers": { source: "grass", untinted: [0] },
+  "minecraft:spruce_leaves": { source: "constant", color: 6396257 },
+  "minecraft:birch_leaves": { source: "constant", color: 8431445 },
+  "minecraft:oak_leaves": { source: "constant", color: 4764952 },
+  "minecraft:jungle_leaves": { source: "constant", color: 4764952 },
+  "minecraft:acacia_leaves": { source: "constant", color: 4764952 },
+  "minecraft:dark_oak_leaves": { source: "constant", color: 4764952 },
+  "minecraft:vine": { source: "constant", color: 4764952 },
+  "minecraft:mangrove_leaves": { source: "constant", color: 4764952 },
+  "minecraft:leaf_litter": { source: "constant", color: 6044722 },
+  "minecraft:water_cauldron": { source: "constant", color: 4159204 },
+  "minecraft:redstone_wire": { source: "redstone" },
+  "minecraft:attached_melon_stem": { source: "constant", color: 14731036 },
+  "minecraft:attached_pumpkin_stem": { source: "constant", color: 14731036 },
+  "minecraft:melon_stem": { source: "stem" },
+  "minecraft:pumpkin_stem": { source: "stem" },
+  "minecraft:lily_pad": { source: "constant", color: 7455580 }
+};
+
+// src/model/block/BlockTints.ts
+var rules = blockTints_default;
+var BlockTints = class {
+  /** Resolves block preview colors without biome context; explicit tints take precedence. */
+  static async get(key, state, model, tints) {
+    const rule = key && rules[key.toNamespacedString()];
+    if (!key || !rule) return tints;
+    const indices = /* @__PURE__ */ new Set();
+    for (const element of model.elements ?? []) {
+      for (const face of Object.values(element.faces)) {
+        const index = face?.tintindex;
+        if (index !== void 0 && index >= 0 && tints?.[index] === void 0 && !rule.untinted?.includes(index)) {
+          indices.add(index);
+        }
+      }
+    }
+    if (!indices.size) return tints;
+    let color;
+    switch (rule.source) {
+      case "constant":
+        color = rule.color;
+        break;
+      case "grass":
+        color = await this.grassColor(key);
+        break;
+      case "redstone": {
+        const power = Number(state.power ?? 0) / 15;
+        const red = power * 0.6 + (power > 0 ? 0.4 : 0.3);
+        const green = Math.max(0, power * power * 0.7 - 0.5);
+        const blue = Math.max(0, power * power * 0.6 - 0.7);
+        color = Math.floor(red * 255) << 16 | Math.floor(green * 255) << 8 | Math.floor(blue * 255);
+        break;
+      }
+      case "stem": {
+        const age = Number(state.age ?? 0);
+        color = age * 32 << 16 | 255 - age * 8 << 8 | age * 4;
+        break;
+      }
+    }
+    return { ...Object.fromEntries([...indices].map((index) => [index, color])), ...tints };
+  }
+  static async grassColor(origin) {
+    const key = AssetKey.parse("textures", "minecraft:colormap/grass", origin);
+    return await Caching.blockTintCache.get(key.serialize(), async () => {
+      const image = await ModelTextures.get(key);
+      if (!image) throw new MineRenderError(`Missing grass colormap: ${key.toNamespacedString()}`);
+      if (image.width !== 256 || image.height !== 256) {
+        throw new MineRenderError("Grass colormaps must be 256 \xD7 256 pixels");
+      }
+      const [red, green, blue] = image.data.getImageData(127, 127, 1, 1).data;
+      return red << 16 | green << 8 | blue;
+    });
+  }
+};
+
 // src/model/scene/ModelObject.ts
-var import_three15 = require("three");
+var import_three16 = require("three");
 
 // src/three/BufferGeometryUtils.js
-var import_three14 = require("three");
+var import_three15 = require("three");
 function computeTangents(geometry) {
   geometry.computeTangents();
   console.warn("THREE.BufferGeometryUtils: .computeTangents() has been removed. Use BufferGeometry.computeTangents() instead.");
@@ -3561,7 +4024,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three14.BufferGeometry();
+  const mergedGeometry = new import_three15.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -3685,7 +4148,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three14.BufferAttribute(array, itemSize, normalized);
+  return new import_three15.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -3701,7 +4164,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three14.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three15.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -3710,7 +4173,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three14.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three15.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -3794,13 +4257,13 @@ function mergeVertices(geometry, tolerance = 1e-4) {
     const name = attributeNames[i];
     const oldAttribute = geometry.getAttribute(name);
     const buffer = new oldAttribute.array.constructor(attrArrays[name]);
-    const attribute = new import_three14.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_three15.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
     result.setAttribute(name, attribute);
     if (name in morphAttrsArrays) {
       for (let j = 0; j < morphAttrsArrays[name].length; j++) {
         const oldMorphAttribute = geometry.morphAttributes[name][j];
         const buffer2 = new oldMorphAttribute.array.constructor(morphAttrsArrays[name][j]);
-        const morphAttribute = new import_three14.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three15.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -3809,11 +4272,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three14.TrianglesDrawMode) {
+  if (drawMode === import_three15.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three14.TriangleFanDrawMode || drawMode === import_three14.TriangleStripDrawMode) {
+  if (drawMode === import_three15.TriangleFanDrawMode || drawMode === import_three15.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -3831,7 +4294,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three14.TriangleFanDrawMode) {
+    if (drawMode === import_three15.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -3867,15 +4330,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new import_three14.Vector3();
-  const _vB = new import_three14.Vector3();
-  const _vC = new import_three14.Vector3();
-  const _tempA = new import_three14.Vector3();
-  const _tempB = new import_three14.Vector3();
-  const _tempC = new import_three14.Vector3();
-  const _morphA = new import_three14.Vector3();
-  const _morphB = new import_three14.Vector3();
-  const _morphC = new import_three14.Vector3();
+  const _vA = new import_three15.Vector3();
+  const _vB = new import_three15.Vector3();
+  const _vC = new import_three15.Vector3();
+  const _tempA = new import_three15.Vector3();
+  const _tempB = new import_three15.Vector3();
+  const _tempC = new import_three15.Vector3();
+  const _morphA = new import_three15.Vector3();
+  const _morphB = new import_three15.Vector3();
+  const _morphC = new import_three15.Vector3();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4070,8 +4533,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three14.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three14.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three15.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three15.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -4081,26 +4544,29 @@ function computeMorphedAttributes(object) {
 }
 
 // src/model/scene/ModelObject.ts
-var import_ts_deepmerge6 = __toESM(require_dist());
-var p10 = prefix("ModelObject");
-var _ModelObject = class _ModelObject extends SceneObject {
+var import_ts_deepmerge5 = __toESM(require_dist());
+var p9 = prefix("ModelObject");
+var ModelObject = class _ModelObject extends SceneObject {
   constructor(originalModel, options) {
     super(options);
     this.originalModel = originalModel;
     this.isModelObject = true;
     this.meshesCreated = false;
-    this.options = (0, import_ts_deepmerge6.default)({}, _ModelObject.DEFAULT_OPTIONS, options ?? {});
+    this.options = (0, import_ts_deepmerge5.default)({}, _ModelObject.DEFAULT_OPTIONS, options ?? {});
+    if (this.options.tints) this.options.tints = { ...this.options.tints };
     console.log("ModelObject options", this.options);
   }
+  static {
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge5.default)({}, SceneObject.DEFAULT_OPTIONS, {});
+  }
   async init() {
     await this.loadTextures();
     this.createMeshes();
     this.applyTextures();
   }
   dispose() {
-    var _a;
     super.dispose();
-    (_a = this.atlas) == null ? void 0 : _a.dispose();
+    this.atlas?.dispose();
   }
   get textureAtlas() {
     return this.atlas;
@@ -4110,20 +4576,38 @@ var _ModelObject = class _ModelObject extends SceneObject {
     this.atlas = await UVMapper.getAtlas(this.originalModel);
   }
   createMeshes(force = false) {
-    var _a;
     if (this.meshesCreated && !force) return;
     const mat = Materials.MISSING_TEXTURE;
+    const displayTransform = this.options.displayPosition ? DisplayTransforms.getMatrix(this.originalModel.display, this.options.displayPosition) : void 0;
     let allGeos = [];
     if (this.atlas) {
       if (this.atlas.model.elements) {
-        (_a = this.atlas.model.elements) == null ? void 0 : _a.forEach((el) => {
+        this.atlas.model.elements?.forEach((el) => {
           const elGeo = this._getBoxGeometryFromElement(el).clone();
-          elGeo.applyMatrix4(new import_three15.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
-          elGeo.applyMatrix4(new import_three15.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+          if (this.options.uvLockRotation) {
+            UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three16.Euler(...this.options.uvLockRotation));
+          }
+          if (this.options.tints) {
+            const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
+            for (const [faceIndex, faceName] of CUBE_FACES.entries()) {
+              const tintIndex = el.faces[faceName]?.tintindex;
+              if (tintIndex === void 0 || tintIndex < 0) continue;
+              const tint = this.options.tints[tintIndex];
+              if (tint === void 0) continue;
+              const color = new import_three16.Color(tint);
+              for (let vertex = 0; vertex < 4; vertex++) {
+                color.toArray(colors, (faceIndex * 4 + vertex) * 3);
+              }
+            }
+            elGeo.setAttribute("color", new import_three16.BufferAttribute(colors, 3));
+          }
+          elGeo.applyMatrix4(new import_three16.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
+          elGeo.applyMatrix4(new import_three16.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
           if (el.rotation) {
             applyElementRotation(el.rotation, elGeo);
           }
-          elGeo.applyMatrix4(new import_three15.Matrix4().makeTranslation(-8, -8, -8));
+          elGeo.applyMatrix4(new import_three16.Matrix4().makeTranslation(-8, -8, -8));
+          if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
           if (this.options.mergeMeshes) {
             allGeos.push(elGeo);
           } else {
@@ -4134,17 +4618,18 @@ var _ModelObject = class _ModelObject extends SceneObject {
           }
         });
       } else {
-        console.debug(p10, this.atlas.model, "has no elements");
+        console.debug(p9, this.atlas.model, "has no elements");
       }
     } else {
-      console.debug(p10, "Missing atlas for", this);
+      console.debug(p9, "Missing atlas for", this);
     }
     if (this.options.mergeMeshes) {
       let combinedGeo;
       if (allGeos.length > 0) {
         combinedGeo = mergeBufferGeometries(allGeos);
       } else {
-        combinedGeo = new import_three15.BoxGeometry(16, 16, 16);
+        combinedGeo = new import_three16.BoxGeometry(16, 16, 16);
+        if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
       }
       combinedGeo.computeBoundingBox();
       let mesh;
@@ -4174,6 +4659,7 @@ var _ModelObject = class _ModelObject extends SceneObject {
         /*TODO: get this from render options*/
       );
       this.iterateAllMeshes((mesh) => {
+        if (mesh.geometry.hasAttribute("color")) mat.vertexColors = true;
         mesh.material = mat;
       });
       if (this.atlas.hasAnimation) {
@@ -4189,17 +4675,25 @@ var _ModelObject = class _ModelObject extends SceneObject {
     }
   }
 };
-_ModelObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge6.default)({}, SceneObject.DEFAULT_OPTIONS, {});
-var ModelObject = _ModelObject;
 function isModelObject(obj) {
   return obj.isModelObject;
 }
 
 // src/model/block/scene/BlockObject.ts
-var import_ts_deepmerge7 = __toESM(require_dist());
-var import_three16 = require("three");
-var p11 = prefix("BlockObject");
-var _BlockObject = class _BlockObject extends SceneObject {
+var import_ts_deepmerge6 = __toESM(require_dist());
+var import_three17 = require("three");
+var p10 = prefix("BlockObject");
+function matchesCondition(condition, state) {
+  return Object.entries(condition).every(([key, value]) => {
+    if (Array.isArray(value)) {
+      if (key === "OR") return value.some((child) => matchesCondition(child, state));
+      if (key === "AND") return value.every((child) => matchesCondition(child, state));
+      return false;
+    }
+    return typeof value === "string" && state[key] !== void 0 && value.split("|").includes(`${state[key]}`);
+  });
+}
+var BlockObject = class _BlockObject extends SceneObject {
   constructor(blockState, options) {
     super(options);
     this.blockState = blockState;
@@ -4212,11 +4706,16 @@ var _BlockObject = class _BlockObject extends SceneObject {
     this._instanceModel = [];
     this._variants = [];
     this._models = [];
-    this.options = (0, import_ts_deepmerge7.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
+    this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
+  }
+  static {
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge6.default)({}, ModelObject.DEFAULT_OPTIONS, {
+      applyDefaultState: true
+    });
   }
   async init() {
     if (this.options.applyDefaultState) {
-      const defaultState = this.blockState.key ? BlockStates.getDefaultState(this.blockState.key) : void 0;
+      const defaultState = this.blockState.key ? await BlockStates.getDefaultState(this.blockState.key) : void 0;
       if (defaultState && Object.keys(defaultState).length > 0) {
         const state = {};
         for (let k in defaultState) {
@@ -4227,15 +4726,9 @@ var _BlockObject = class _BlockObject extends SceneObject {
         if (this.blockState.variants) {
           await this.setState(Object.keys(this.blockState.variants)[0]);
         } else if (this.blockState.multipart) {
-          for (let part of this.blockState.multipart) {
-            if (part.when && !("OR" in part.when)) {
-              const k = Object.keys(part.when)[0];
-              if (k) {
-                await this.setState(k, part.when[k].split("|")[0]);
-                break;
-              }
-            }
-          }
+          const condition = this.blockState.multipart.map((part) => part.when).find((when) => when !== void 0 && Object.values(when).every((value) => typeof value === "string"));
+          const state = Object.fromEntries(Object.entries(condition ?? {}).map(([key, value]) => [key, value.split("|")[0]]));
+          await this.setState(state);
         }
       }
     } else {
@@ -4250,7 +4743,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
       if (isModelObject(model)) {
         model.removeFromScene();
       } else if (isInstanceReference(model)) {
-        model.setScale(new import_three16.Vector3(0, 0, 0));
+        model.setScale(new import_three17.Vector3(0, 0, 0));
       }
     }
     super.removeFromScene();
@@ -4292,55 +4785,11 @@ var _BlockObject = class _BlockObject extends SceneObject {
     } else if (this.blockState.multipart) {
       for (let part of this.blockState.multipart) {
         if (!part.apply) {
-          console.debug(p11, "Missing apply for blockState part", part);
+          console.debug(p10, "Missing apply for blockState part", part);
           continue;
         }
-        if (!part.when) {
+        if (!part.when || matchesCondition(part.when, state)) {
           out.push(this.getSingleVariant(part.apply));
-        } else {
-          let matches = true;
-          if ("OR" in part.when) {
-            const or = part.when.OR;
-            let anyMatch = false;
-            for (let o of or) {
-              for (let k in o) {
-                const split = o[k].split("|");
-                let m = false;
-                for (let s of split) {
-                  if (`${state[k]}` === `${s}`) {
-                    m = true;
-                    break;
-                  }
-                }
-                if (m) {
-                  anyMatch = true;
-                  break;
-                }
-              }
-            }
-            if (!anyMatch) {
-              matches = false;
-            }
-          } else {
-            for (let k in part.when) {
-              const split = part.when[k].split("|");
-              let m = false;
-              for (let s of split) {
-                if (`${state[k]}` === `${s}`) {
-                  m = true;
-                  break;
-                }
-              }
-              if (!m) {
-                matches = false;
-                break;
-              }
-            }
-          }
-          if (matches) {
-            const variants = part.apply;
-            out.push(this.getSingleVariant(variants));
-          }
         }
       }
     }
@@ -4355,7 +4804,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     }
     for (let model of this._models) {
       if (isInstanceReference(model)) {
-        model.setScale(new import_three16.Vector3(0, 0, 0));
+        model.setScale(new import_three17.Vector3(0, 0, 0));
       } else {
         model.dispose();
       }
@@ -4370,11 +4819,21 @@ var _BlockObject = class _BlockObject extends SceneObject {
     }
   }
   getSingleVariant(variants) {
-    if (Array.isArray(variants)) {
-      return variants[0];
-    } else {
-      return variants;
-    }
+    if (!Array.isArray(variants)) return variants;
+    if (!variants.length) throw new MineRenderError("Blockstate variant arrays must not be empty");
+    const total = variants.reduce((sum, variant) => {
+      const weight = variant.weight ?? 1;
+      if (!Number.isInteger(weight) || weight < 1) {
+        throw new MineRenderError(`Invalid blockstate variant weight: ${weight}`);
+      }
+      return sum + weight;
+    }, 0);
+    let choice = Math.random() * total;
+    for (const variant of variants) {
+      choice -= variant.weight ?? 1;
+      if (choice < 0) return variant;
+    }
+    return variants[variants.length - 1];
   }
   // @deprecated
   async createAVariant(variants, instanceInfo) {
@@ -4382,28 +4841,27 @@ var _BlockObject = class _BlockObject extends SceneObject {
     await this.createVariant(variant);
   }
   async createVariant(variant) {
-    const model = await Models.getMerged(AssetKey.parse("models", variant.model));
-    const obj = await this.scene.addModel(model, this.options);
-    if (isInstanceReference(obj) || obj.isInstanced) {
-      this._isInstanced = true;
-      this._instanceCounter = 1;
-    }
-    let rotation = new import_three16.Euler(0, 0, 0);
+    const rotation = new import_three17.Euler();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
     if (typeof variant.y !== "undefined") {
-      if (typeof variant.x !== "undefined") {
-        rotation.y = toRadians(clampRotationDegrees(variant.y));
-      } else {
-        rotation.y = toRadians(clampRotationDegrees(360 - variant.y));
-      }
+      rotation.y = toRadians(clampRotationDegrees(typeof variant.x !== "undefined" ? variant.y : 360 - variant.y));
+    }
+    const modelKey = AssetKey.parse("models", variant.model);
+    modelKey.root = this.blockState.key?.root;
+    const model = await Models.getMerged(modelKey);
+    const options = {
+      ...this.options,
+      tints: model ? await BlockTints.get(this.blockState.key, this.state, model, this.options.tints) : this.options.tints,
+      uvLockRotation: variant.uvlock && (rotation.x !== 0 || rotation.y !== 0) ? [rotation.x, rotation.y, rotation.z] : void 0
+    };
+    const obj = await this.scene.addModel(model, options);
+    if (isInstanceReference(obj) || obj.isInstanced) {
+      this._isInstanced = true;
+      this._instanceCounter = 1;
     }
     obj.setRotation(rotation);
-    setTimeout(() => {
-      obj.setRotation(rotation);
-    }, 150);
-    console.log(obj);
     return obj;
   }
   async resetState() {
@@ -4472,7 +4930,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new import_three16.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three17.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -4493,18 +4951,15 @@ var _BlockObject = class _BlockObject extends SceneObject {
     }
   }
   setPosition(position) {
-    super.setPosition(position);
+    this.position.copy(position);
     for (let model of this._models) {
       model.setPosition(position);
     }
+    this.notifyDirty();
   }
   //TODO: should override rotation + scale methods
   //TODO
 };
-_BlockObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge7.default)({}, ModelObject.DEFAULT_OPTIONS, {
-  applyDefaultState: true
-});
-var BlockObject = _BlockObject;
 function isBlockObject(obj) {
   return obj.isBlockObject;
 }
@@ -4529,11 +4984,10 @@ var StructureParser = class {
       throw new MineRenderError("Structure does not have palette(s)");
     }
     const blocks = nbt.blocks.value.value.map((block) => {
-      var _a;
       const state = palette.value.value[block.state.value];
       if (state.Name.value === "minecraft:air") return void 0;
       const props = {};
-      for (let k in (_a = state.Properties) == null ? void 0 : _a.value) {
+      for (let k in state.Properties?.value) {
         props[k] = state.Properties.value[k].value;
       }
       return {
@@ -4551,8 +5005,8 @@ var StructureParser = class {
 };
 
 // src/renderer/MineRenderScene.ts
-var import_three17 = require("three");
-var import_ts_deepmerge9 = __toESM(require_dist());
+var import_three19 = require("three");
+var import_ts_deepmerge8 = __toESM(require_dist());
 
 // src/skin/SkinPart.ts
 var SkinPart = /* @__PURE__ */ ((SkinPart2) => {
@@ -5188,62 +5642,52 @@ var baseSkinCoordinates = {
     }
   },
   cape: {
-    //TODO
-    east: {
-      uv: [
-        0,
-        36,
-        4,
-        48
-      ]
-    },
-    west: {
-      uv: [
-        8,
-        36,
-        12,
-        48
-      ]
-    },
-    north: {
-      uv: [
-        4,
-        36,
-        8,
-        48
-      ]
-    },
-    south: {
-      uv: [
-        12,
-        36,
-        16,
-        48
-      ]
-    },
-    up: {
-      uv: [
-        4,
-        32,
-        8,
-        36
-      ]
-    },
-    down: {
-      uv: [
-        8,
-        32,
-        12,
-        36
-      ],
-      rotation: 180
-    }
+    east: { uv: [0, 1, 1, 17] },
+    west: { uv: [11, 1, 12, 17] },
+    north: { uv: [1, 1, 11, 17] },
+    south: { uv: [12, 1, 22, 17] },
+    up: { uv: [11, 1, 1, 0] },
+    down: { uv: [21, 0, 11, 1] }
   }
 };
 var classicSkinTextureCoordinates = {
   ...baseSkinCoordinates
 };
-var slimSkinTextureCoordinates = { ...baseSkinCoordinates };
+var slimSkinTextureCoordinates = {
+  ...baseSkinCoordinates,
+  leftArm: {
+    ...baseSkinCoordinates.leftArm,
+    west: { uv: [39, 52, 43, 64] },
+    north: { uv: [36, 52, 39, 64] },
+    south: { uv: [43, 52, 46, 64] },
+    up: { uv: [39, 52, 36, 48] },
+    down: { uv: [42, 48, 39, 52] }
+  },
+  rightArm: {
+    ...baseSkinCoordinates.rightArm,
+    west: { uv: [47, 20, 51, 32] },
+    north: { uv: [44, 20, 47, 32] },
+    south: { uv: [51, 20, 54, 32] },
+    up: { uv: [47, 20, 44, 16] },
+    down: { uv: [50, 16, 47, 20] }
+  },
+  leftSleeve: {
+    ...baseSkinCoordinates.leftSleeve,
+    west: { uv: [55, 52, 59, 64] },
+    north: { uv: [52, 52, 55, 64] },
+    south: { uv: [59, 52, 62, 64] },
+    up: { uv: [55, 52, 52, 48] },
+    down: { uv: [58, 48, 55, 52], rotation: 180 }
+  },
+  rightSleeve: {
+    ...baseSkinCoordinates.rightSleeve,
+    west: { uv: [47, 36, 51, 48] },
+    north: { uv: [44, 36, 47, 48] },
+    south: { uv: [51, 36, 54, 48] },
+    up: { uv: [47, 36, 44, 32] },
+    down: { uv: [50, 32, 47, 36], rotation: 180 }
+  }
+};
 
 // src/skin/SkinGeometries.ts
 var box8inner = [8, 8, 8];
@@ -5283,15 +5727,118 @@ var slimSkinGeometries = {
 };
 
 // src/skin/scene/SkinObject.ts
-var import_ts_deepmerge8 = __toESM(require_dist());
+var import_ts_deepmerge7 = __toESM(require_dist());
+
+// src/skin/SkinTextures.ts
+var import_three18 = require("three");
+var SkinTextures = class {
+  static async get(src, legacy) {
+    const image = await ImageLoader.getData(src);
+    const scale = image.width / 64;
+    if (!Number.isInteger(scale) || scale < 1 || image.height !== image.width && image.height !== image.width / 2) {
+      throw new MineRenderError(`Invalid skin dimensions ${image.width}x${image.height}; expected 64x64 or 64x32, or an integer-scaled equivalent`);
+    }
+    const isLegacy = legacy ?? image.height === image.width / 2;
+    if (!isLegacy && image.height !== image.width) {
+      throw new MineRenderError(`Invalid skin dimensions ${image.width}x${image.height}; non-legacy skins must be square`);
+    }
+    const slim = !isLegacy && this.isSlim(image, scale);
+    const key = `skin:${serializeImageKey({ src })}:${isLegacy}`;
+    const material = Caching.materialCache.get(key, () => {
+      const pixels = isLegacy ? this.normalizeLegacy(image, scale) : new Uint8Array(image.data);
+      return this.createMaterial(pixels, image.width, image.width);
+    });
+    return { material, slim, legacy: isLegacy };
+  }
+  static async getCape(src, layout = "minecraft") {
+    const image = await ImageLoader.getData(src);
+    const scale = image.width / 64;
+    if (layout === "minecraft" && (!Number.isInteger(scale) || scale < 1 || image.height !== image.width / 2)) {
+      throw new MineRenderError(`Invalid cape dimensions ${image.width}x${image.height}; expected 64x32 or an integer-scaled equivalent`);
+    }
+    return Caching.materialCache.get(`cape:${serializeImageKey({ src })}`, () => {
+      return this.createMaterial(new Uint8Array(image.data), image.width, image.height, false);
+    });
+  }
+  static createMaterial(pixels, width, height, transparent = true) {
+    const texture = Textures.initTextureProps(new import_three18.DataTexture(pixels, width, height));
+    texture.colorSpace = import_three18.SRGBColorSpace;
+    texture.flipY = true;
+    texture.needsUpdate = true;
+    return new import_three18.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three18.DoubleSide : import_three18.FrontSide, alphaTest: transparent ? 0.5 : 0 });
+  }
+  static isSlim(image, scale) {
+    for (const [x, y] of [[46, 52], [54, 20]]) {
+      for (let row = y * scale; row < (y + 12) * scale; row++) {
+        for (let column = x * scale; column < (x + 1) * scale; column++) {
+          if (image.data[(row * image.width + column) * 4 + 3] !== 0) return false;
+        }
+      }
+    }
+    return true;
+  }
+  static normalizeLegacy(image, scale) {
+    const pixels = new Uint8Array(image.width * image.width * 4);
+    pixels.set(image.data.subarray(0, image.width * image.width / 2 * 4));
+    for (const [sx, sy, dx, dy, width, height] of [
+      [4, 16, 20, 48, 4, 4],
+      [8, 16, 24, 48, 4, 4],
+      [0, 20, 24, 52, 4, 12],
+      [4, 20, 20, 52, 4, 12],
+      [8, 20, 16, 52, 4, 12],
+      [12, 20, 28, 52, 4, 12],
+      [44, 16, 36, 48, 4, 4],
+      [48, 16, 40, 48, 4, 4],
+      [40, 20, 40, 52, 4, 12],
+      [44, 20, 36, 52, 4, 12],
+      [48, 20, 32, 52, 4, 12],
+      [52, 20, 44, 52, 4, 12]
+    ]) {
+      for (let y = 0; y < height * scale; y++) {
+        for (let x = 0; x < width * scale; x++) {
+          const source = ((sy * scale + y) * image.width + sx * scale + x) * 4;
+          const target = ((dy * scale + y) * image.width + (dx + width) * scale - 1 - x) * 4;
+          pixels.set(image.data.subarray(source, source + 4), target);
+        }
+      }
+    }
+    let clearHat = true;
+    for (let y = 0; y < 32 * scale; y++) {
+      for (let x = 32 * scale; x < image.width; x++) {
+        if (pixels[(y * image.width + x) * 4 + 3] < 128) clearHat = false;
+      }
+    }
+    for (let y = 0; y < image.width; y++) {
+      for (let x = 0; x < image.width; x++) {
+        const alpha = (y * image.width + x) * 4 + 3;
+        if (x < 32 * scale && y < 16 * scale || y >= 16 * scale && y < 32 * scale || x >= 16 * scale && x < 48 * scale && y >= 48 * scale) {
+          pixels[alpha] = 255;
+        } else if (clearHat && x >= 32 * scale && y < 32 * scale) {
+          pixels[alpha] = 0;
+        }
+      }
+    }
+    return pixels;
+  }
+};
+
+// src/skin/CapeLayout.ts
+var capeTextureSizes = {
+  minecraft: [64, 32],
+  optifine: [46, 22],
+  labymod: [22, 17]
+};
+
+// src/skin/scene/SkinObject.ts
 var SkinObject = class extends SceneObject {
   constructor(options) {
     super();
     this.slim = false;
-    this.legacy = false;
-    this.skinTextureWidth = 64;
-    this.skinTextureHeight = 64;
-    this.options = (0, import_ts_deepmerge8.default)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
+    this.detectedSlim = false;
+    this.skinLoad = 0;
+    this.capeLoad = 0;
+    this.options = (0, import_ts_deepmerge7.default)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
+    this.slim = this.options.slim ?? false;
   }
   async init() {
     this.createMeshes();
@@ -5300,15 +5847,13 @@ var SkinObject = class extends SceneObject {
   }
   createMeshes() {
     console.log("#createMeshes");
-    const mat = Materials.MISSING_TEXTURE;
+    const mat = this.skinMaterial ?? Materials.MISSING_TEXTURE;
     {
       const headGroup = this.createAndAddGroup("head", 0, 28, 0, "y" /* Y */, -4);
       const headGeo = this.getBoxGeometry("head" /* HEAD */);
       const head = this.createAndAddMesh("head", headGroup, headGeo, mat, "y" /* Y */, 4);
-      if (!this.legacy) {
-        const hatGeo = this.getBoxGeometry("hat" /* HAT */);
-        const hat = this.createAndAddMesh("hat", headGroup, hatGeo, 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, 18, 0);
@@ -5351,51 +5896,95 @@ var SkinObject = class extends SceneObject {
     }
     console.log("#createMeshes done");
   }
-  setSkinTexture(src) {
+  async setSkinTexture(src) {
     if (typeof src === "undefined") return;
     this.skinTextureSrc = src;
-    const mat = Materials.getImage({
-      texture: { src },
-      transparent: true
-    });
-    for (let part of SKIN_PARTS) {
-      let mesh = this.getMeshByName(part);
+    const load = ++this.skinLoad;
+    const texture = await SkinTextures.get(src, this.options.legacy);
+    if (load !== this.skinLoad) return;
+    this.skinMaterial = texture.material;
+    this.detectedSlim = texture.slim;
+    this.updateSlim(this.options.slim ?? this.detectedSlim);
+    for (const part of SKIN_PARTS) {
+      if (part === "cape" /* CAPE */) continue;
+      const mesh = this.getMeshByName(part);
       if (mesh) {
-        mesh.material = mat;
+        mesh.material = texture.material;
       }
     }
+    this.notifyDirty();
+  }
+  /** Load a cape texture in the selected layout, or pass undefined to remove the cape. */
+  async setCapeTexture(src, layout = "minecraft") {
+    const load = ++this.capeLoad;
+    if (src === void 0) {
+      const group = this.getGroupByName("cape" /* CAPE */);
+      if (group) this.remove(group);
+      this.notifyDirty();
+      return;
+    }
+    const material = await SkinTextures.getCape(src, layout);
+    if (load !== this.capeLoad) return;
+    const size = capeTextureSizes[layout];
+    const geometry = this._getBoxGeometryFromDimensions(
+      classicSkinGeometries.cape,
+      classicSkinTextureCoordinates.cape,
+      size,
+      size
+    );
+    const mesh = this.getMeshByName("cape" /* CAPE */);
+    if (mesh) {
+      mesh.material = material;
+      mesh.geometry = geometry;
+    } else {
+      const group = this.createAndAddGroup("cape" /* CAPE */, 0, 24, 2);
+      group.rotation.set(toRadians(-6), Math.PI, 0);
+      const cape = this.createAndAddMesh("cape" /* CAPE */, group, geometry, material);
+      cape.position.set(0, -8, -0.5);
+    }
+    this.notifyDirty();
   }
-  //TODO: cape
+  /** Select the arm model, or pass undefined to use texture detection. */
   setSlim(slim) {
-    console.log("#setSlim");
-    const changed = slim !== this.slim;
+    this.options.slim = slim;
+    this.updateSlim(slim ?? this.detectedSlim);
+  }
+  updateSlim(slim) {
+    if (slim === this.slim) return;
     this.slim = slim;
-    if (changed) {
-      this.createMeshes();
-    }
-    if (changed) {
-      if (this.skinTextureSrc) {
-        this.setSkinTexture(this.skinTextureSrc);
-      }
-    }
-    console.log("#setSlim done");
+    for (const part of ["leftArm" /* LEFT_ARM */, "leftSleeve" /* LEFT_SLEEVE */, "rightArm" /* RIGHT_ARM */, "rightSleeve" /* RIGHT_SLEEVE */]) {
+      const mesh = this.getMeshByName(part);
+      if (mesh) mesh.geometry = this.getBoxGeometry(part);
+    }
+    const offset = slim ? 0.5 : -0.5;
+    const leftArm = this.getGroupByName("leftArm" /* LEFT_ARM */);
+    const rightArm = this.getGroupByName("rightArm" /* RIGHT_ARM */);
+    if (leftArm) leftArm.position.x += offset;
+    if (rightArm) rightArm.position.x -= offset;
+    this.notifyDirty();
   }
-  setLegacy(legacy) {
-    if (legacy !== this.legacy) {
-    }
-    this.legacy = legacy;
+  /** Select the texture layout, or pass undefined to detect it from image dimensions. */
+  async setLegacy(legacy) {
+    if (legacy === this.options.legacy) return;
+    this.options.legacy = legacy;
+    if (this.skinTextureSrc) await this.setSkinTexture(this.skinTextureSrc);
+  }
+  dispose() {
+    this.skinLoad++;
+    this.capeLoad++;
+    super.dispose();
   }
   //TODO: layer toggles
   getBoxGeometry(part) {
     console.log("slim", this.slim);
     const coordinates = this.slim ? slimSkinTextureCoordinates : classicSkinTextureCoordinates;
     const geometries = this.slim ? slimSkinGeometries : classicSkinGeometries;
-    return this._getBoxGeometryFromDimensions(geometries[part], coordinates[part], [64, 64], [this.skinTextureWidth, this.skinTextureHeight]);
+    return this._getBoxGeometryFromDimensions(geometries[part], coordinates[part], [64, 64], [64, 64]);
   }
 };
 
 // src/renderer/MineRenderScene.ts
-var _MineRenderScene = class _MineRenderScene extends import_three17.Scene {
+var MineRenderScene = class _MineRenderScene extends import_three19.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -5404,12 +5993,14 @@ var _MineRenderScene = class _MineRenderScene extends import_three17.Scene {
     this.dirty = true;
     this.observedObjects = /* @__PURE__ */ new Set();
     this.onObjectChange = (event) => {
-      var _a;
-      if (((_a = event.target) == null ? void 0 : _a.parent) === this) {
+      if (event.target?.parent === this) {
         this.dirty = true;
       }
     };
-    this.options = (0, import_ts_deepmerge9.default)({}, _MineRenderScene.DEFAULT_OPTIONS, options ?? {});
+    this.options = (0, import_ts_deepmerge8.default)({}, _MineRenderScene.DEFAULT_OPTIONS, options ?? {});
+  }
+  static {
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge8.default)({}, {});
   }
   add(...objects) {
     for (const object of objects) {
@@ -5417,7 +6008,7 @@ var _MineRenderScene = class _MineRenderScene extends import_three17.Scene {
       try {
         super.add(object);
       } finally {
-        if ((object == null ? void 0 : object.isObject3D) && object !== this) {
+        if (object?.isObject3D && object !== this) {
           this.updateObjectRegistration(object, object.parent === this);
         }
       }
@@ -5460,15 +6051,21 @@ var _MineRenderScene = class _MineRenderScene extends import_three17.Scene {
     return this.add(...object);
   }
   async addSceneObject(asset, objectSupplier, _options, parent = this) {
-    var _a, _b;
     console.log("addSceneObject", asset);
     console.log("parent", parent);
     console.log(_options);
     this.dirty = true;
     const obj = await objectSupplier();
-    if (((_a = obj == null ? void 0 : obj.options) == null ? void 0 : _a.instanceMeshes) && asset.key && ((_b = asset.key) == null ? void 0 : _b.assetType) === "models") {
+    if (obj?.options?.instanceMeshes && asset.key && asset.key?.assetType === "models") {
       console.log("instanceMeshes + key");
-      const key = asset.key.serialize();
+      let key = asset.key.serialize();
+      if (isModelObject(obj)) {
+        const { displayPosition, uvLockRotation, tints } = obj.options;
+        if (displayPosition) key += `|display:${displayPosition}`;
+        if (uvLockRotation) key += `|uvlock:${uvLockRotation.join(",")}`;
+        const palette = Object.entries(tints ?? {}).sort(([a], [b]) => Number(a) - Number(b));
+        if (palette.length) key += `|tints:${JSON.stringify(palette)}`;
+      }
       return this.instanceManager.getOrCreate(key, async () => {
         obj.scene = this;
         await obj.init();
@@ -5495,10 +6092,10 @@ var _MineRenderScene = class _MineRenderScene extends import_three17.Scene {
     this.dirty = true;
     const obj = new SkinObject(options);
     obj.scene = this;
-    await obj.init();
     if (skin) {
-      obj.setSkinTexture(skin);
+      await obj.setSkinTexture(skin);
     }
+    await obj.init();
     parent.add(obj);
     return obj;
   }
@@ -5506,24 +6103,22 @@ var _MineRenderScene = class _MineRenderScene extends import_three17.Scene {
     return this.addSceneObject(entity, () => new EntityObject(entity, options), options, parent);
   }
 };
-_MineRenderScene.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {});
-var MineRenderScene = _MineRenderScene;
 function isMineRenderScene(obj) {
   return obj.isMineRenderScene;
 }
 
 // src/renderer/Renderer.ts
-var import_three19 = require("three");
-var import_ts_deepmerge10 = __toESM(require_dist());
+var import_three21 = require("three");
+var import_ts_deepmerge9 = __toESM(require_dist());
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
 
 // src/three/OrbitControls.js
-var import_three18 = require("three");
+var import_three20 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three18.EventDispatcher {
+var OrbitControls = class extends import_three20.EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -5532,7 +6127,7 @@ var OrbitControls = class extends import_three18.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three18.Vector3();
+    this.target = new import_three20.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -5554,8 +6149,8 @@ var OrbitControls = class extends import_three18.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three18.MOUSE.ROTATE, MIDDLE: import_three18.MOUSE.DOLLY, RIGHT: import_three18.MOUSE.PAN };
-    this.touches = { ONE: import_three18.TOUCH.ROTATE, TWO: import_three18.TOUCH.DOLLY_PAN };
+    this.mouseButtons = { LEFT: import_three20.MOUSE.ROTATE, MIDDLE: import_three20.MOUSE.DOLLY, RIGHT: import_three20.MOUSE.PAN };
+    this.touches = { ONE: import_three20.TOUCH.ROTATE, TWO: import_three20.TOUCH.DOLLY_PAN };
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -5584,11 +6179,11 @@ var OrbitControls = class extends import_three18.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three18.Vector3();
-      const quat = new import_three18.Quaternion().setFromUnitVectors(object.up, new import_three18.Vector3(0, 1, 0));
+      const offset = new import_three20.Vector3();
+      const quat = new import_three20.Quaternion().setFromUnitVectors(object.up, new import_three20.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three18.Vector3();
-      const lastQuaternion = new import_three18.Quaternion();
+      const lastPosition = new import_three20.Vector3();
+      const lastQuaternion = new import_three20.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -5674,20 +6269,20 @@ var OrbitControls = class extends import_three18.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three18.Spherical();
-    const sphericalDelta = new import_three18.Spherical();
+    const spherical = new import_three20.Spherical();
+    const sphericalDelta = new import_three20.Spherical();
     let scale = 1;
-    const panOffset = new import_three18.Vector3();
+    const panOffset = new import_three20.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three18.Vector2();
-    const rotateEnd = new import_three18.Vector2();
-    const rotateDelta = new import_three18.Vector2();
-    const panStart = new import_three18.Vector2();
-    const panEnd = new import_three18.Vector2();
-    const panDelta = new import_three18.Vector2();
-    const dollyStart = new import_three18.Vector2();
-    const dollyEnd = new import_three18.Vector2();
-    const dollyDelta = new import_three18.Vector2();
+    const rotateStart = new import_three20.Vector2();
+    const rotateEnd = new import_three20.Vector2();
+    const rotateDelta = new import_three20.Vector2();
+    const panStart = new import_three20.Vector2();
+    const panEnd = new import_three20.Vector2();
+    const panDelta = new import_three20.Vector2();
+    const dollyStart = new import_three20.Vector2();
+    const dollyEnd = new import_three20.Vector2();
+    const dollyDelta = new import_three20.Vector2();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -5703,7 +6298,7 @@ var OrbitControls = class extends import_three18.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three18.Vector3();
+      const v = new import_three20.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -5711,7 +6306,7 @@ var OrbitControls = class extends import_three18.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three18.Vector3();
+      const v = new import_three20.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -5724,7 +6319,7 @@ var OrbitControls = class extends import_three18.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three18.Vector3();
+      const offset = new import_three20.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -5973,12 +6568,12 @@ var OrbitControls = class extends import_three18.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three18.MOUSE.DOLLY:
+        case import_three20.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three18.MOUSE.ROTATE:
+        case import_three20.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -5989,7 +6584,7 @@ var OrbitControls = class extends import_three18.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three18.MOUSE.PAN:
+        case import_three20.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -6045,12 +6640,12 @@ var OrbitControls = class extends import_three18.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three18.TOUCH.ROTATE:
+            case import_three20.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three18.TOUCH.PAN:
+            case import_three20.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -6061,12 +6656,12 @@ var OrbitControls = class extends import_three18.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three18.TOUCH.DOLLY_PAN:
+            case import_three20.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three18.TOUCH.DOLLY_ROTATE:
+            case import_three20.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -6133,7 +6728,7 @@ var OrbitControls = class extends import_three18.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three18.Vector2();
+        position = new import_three20.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -6153,19 +6748,17 @@ var MapControls = class extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three18.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three18.MOUSE.ROTATE;
-    this.touches.ONE = import_three18.TOUCH.PAN;
-    this.touches.TWO = import_three18.TOUCH.DOLLY_ROTATE;
+    this.mouseButtons.LEFT = import_three20.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three20.MOUSE.ROTATE;
+    this.touches.ONE = import_three20.TOUCH.PAN;
+    this.touches.TWO = import_three20.TOUCH.DOLLY_ROTATE;
   }
 };
 
 // src/renderer/Renderer.ts
-var _Renderer = class _Renderer {
+var Renderer = class _Renderer {
   constructor(options) {
     this._dirty = true;
-    this._animationTimer = void 0;
-    this._animationFrame = void 0;
     this._resizeListener = void 0;
     this._disposed = false;
     this._debugHelpers = [];
@@ -6173,9 +6766,9 @@ var _Renderer = class _Renderer {
     this._changeListener = () => {
       this._dirty = true;
     };
-    this.options = (0, import_ts_deepmerge10.default)({}, _Renderer.DEFAULT_OPTIONS, options ?? {});
+    this.options = (0, import_ts_deepmerge9.default)({}, _Renderer.DEFAULT_OPTIONS, options ?? {});
     this._animationLoop = this.animate.bind(this);
-    this._fpsTimer = this.options.render.fpsLimit > 0 ? 1e3 / this.options.render.fpsLimit : void 0;
+    this._frameInterval = this.options.render.fpsLimit > 0 ? 1e3 / this.options.render.fpsLimit : void 0;
     this._scene = this.createScene();
     this._camera = this.createCamera();
     this._renderer = this.createRenderer();
@@ -6187,6 +6780,45 @@ var _Renderer = class _Renderer {
     this.init();
     this._controls = this.createControls();
   }
+  static {
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
+      camera: {
+        type: "perspective",
+        near: 1,
+        far: 5e3,
+        perspective: {
+          aspect: void 0,
+          fov: 50
+        },
+        orthographic: {
+          left: void 0,
+          right: void 0,
+          top: void 0,
+          bottom: void 0
+        },
+        position: new import_three21.Vector3(50, 50, 50),
+        lookingAt: new import_three21.Vector3(0, 0, 0)
+      },
+      render: {
+        fpsLimit: 60,
+        stats: false,
+        antialias: true,
+        shade: true,
+        autoResize: true,
+        renderAlways: false
+      },
+      composer: {
+        enabled: true
+      },
+      controls: {
+        enabled: false
+      },
+      debug: {
+        grid: false,
+        axes: false
+      }
+    });
+  }
   //<editor-fold desc="INIT">
   createScene() {
     return new MineRenderScene();
@@ -6195,14 +6827,14 @@ var _Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three19.PerspectiveCamera(
+        return new import_three21.PerspectiveCamera(
           this.options.camera.perspective.fov,
           this.options.camera.perspective.aspect ?? this.viewWidth / this.viewHeight,
           this.options.camera.near,
           this.options.camera.far
         );
       case "orthographic":
-        return new import_three19.OrthographicCamera(
+        return new import_three21.OrthographicCamera(
           this.options.camera.orthographic.left ?? this.viewWidth / -2,
           this.options.camera.orthographic.right ?? this.viewWidth / 2,
           this.options.camera.orthographic.top ?? this.viewHeight / 2,
@@ -6213,7 +6845,7 @@ var _Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new import_three19.WebGLRenderer({
+    const renderer = new import_three21.WebGLRenderer({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -6221,21 +6853,20 @@ var _Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three19.PCFSoftShadowMap;
-    renderer.outputEncoding = import_three19.LinearEncoding;
+    renderer.shadowMap.type = import_three21.PCFSoftShadowMap;
+    renderer.outputColorSpace = import_three21.SRGBColorSpace;
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
   }
   createComposer() {
+    if (!this.options.composer.enabled) return void 0;
     const composer = new import_postprocessing.EffectComposer(this.renderer);
-    if (!this.options.composer.enabled) return composer;
     composer.setSize(this.viewWidth, this.viewHeight);
     composer.addPass(new import_postprocessing.RenderPass(this.scene, this.camera));
     return composer;
   }
   createControls() {
-    var _a;
-    if (!((_a = this.options.controls) == null ? void 0 : _a.enabled)) return void 0;
+    if (!this.options.controls?.enabled) return void 0;
     const position = this.camera.position.clone();
     const controls = new OrbitControls(this.camera, this.renderer.domElement);
     this.camera.position.copy(position);
@@ -6257,20 +6888,20 @@ var _Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three19.GridHelper(128, 16);
+      const gridHelper = new import_three21.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three19.GridHelper(128, 16);
+      const gridHelper2 = new import_three21.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three19.GridHelper(128, 16);
+      const gridHelper3 = new import_three21.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper3);
       gridHelper3.rotation.z = 90 * (Math.PI / 180);
       this.scene.add(gridHelper3);
     }
     if (this.options.debug.axes) {
-      const axesHelper = new import_three19.AxesHelper(64);
+      const axesHelper = new import_three21.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -6338,7 +6969,7 @@ var _Renderer = class _Renderer {
       this.camera.updateProjectionMatrix();
     }
     this.renderer.setSize(width, height);
-    this.composer.setSize(width, height);
+    this.composer?.setSize(width, height);
     this._dirty = true;
   }
   //<editor-fold desc="RENDER">
@@ -6357,12 +6988,7 @@ var _Renderer = class _Renderer {
   stop() {
     if (this._disposed) return;
     this.renderer.setAnimationLoop(null);
-    if (this._animationTimer)
-      clearTimeout(this._animationTimer);
-    this._animationTimer = void 0;
-    if (this._animationFrame)
-      cancelAnimationFrame(this._animationFrame);
-    this._animationFrame = void 0;
+    this._nextFrameTime = void 0;
   }
   /**
    * Stops rendering and releases owned resources. Repeated calls have no effect, and a disposed
@@ -6370,7 +6996,6 @@ var _Renderer = class _Renderer {
    * controls must be managed by their owners.
    */
   dispose() {
-    var _a;
     if (this._disposed) return;
     this.stop();
     this._disposed = true;
@@ -6384,7 +7009,7 @@ var _Renderer = class _Renderer {
       }
     }
     this._eventDispatchers.clear();
-    (_a = this._stats) == null ? void 0 : _a.dom.remove();
+    this._stats?.dom.remove();
     this._stats = void 0;
     this.renderer.domElement.remove();
     this._element = void 0;
@@ -6403,26 +7028,30 @@ var _Renderer = class _Renderer {
       }
     }
     this._debugHelpers.length = 0;
-    this.composer.dispose();
+    this.composer?.dispose();
     this.renderer.dispose();
     this.renderer.forceContextLoss();
   }
-  animate(t) {
-    var _a;
+  animate(t = performance.now()) {
     if (this._disposed) return;
-    if (this._stats) {
-      this._stats.begin();
-    }
-    if ((_a = this._controls) == null ? void 0 : _a.enabled) {
+    if (this._controls?.enabled) {
       this._controls.update();
     }
     if (this._disposed) return;
-    if (this.dirty || this.options.render.renderAlways) {
-      if (this.options.composer.enabled) {
-        this.composer.render();
-      } else {
-        this.renderer.render(this.scene, this.camera);
-      }
+    if (!this.dirty && !this.options.render.renderAlways) return;
+    const interval = this._frameInterval;
+    if (interval) {
+      const next = this._nextFrameTime;
+      if (next !== void 0 && t + 0.1 < next) return;
+      this._nextFrameTime = next !== void 0 && t - next < interval ? next + interval : t + interval;
+    }
+    if (this._stats) {
+      this._stats.begin();
+    }
+    if (this.options.composer.enabled && this.composer) {
+      this.composer.render();
+    } else {
+      this.renderer.render(this.scene, this.camera);
     }
     this.dirty = false;
     if (this._stats) {
@@ -6438,12 +7067,10 @@ var _Renderer = class _Renderer {
     return this.element === document.body;
   }
   get viewWidth() {
-    var _a;
-    return this.attachedToBody ? window.innerWidth : ((_a = this.element) == null ? void 0 : _a.offsetWidth) || 0;
+    return this.attachedToBody ? window.innerWidth : this.element?.offsetWidth || 0;
   }
   get viewHeight() {
-    var _a;
-    return this.attachedToBody ? window.innerHeight : ((_a = this.element) == null ? void 0 : _a.offsetHeight) || 0;
+    return this.attachedToBody ? window.innerHeight : this.element?.offsetHeight || 0;
   }
   get scene() {
     return this._scene;
@@ -6463,44 +7090,6 @@ var _Renderer = class _Renderer {
   }
   ///
 };
-_Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge10.default)({}, {
-  camera: {
-    type: "perspective",
-    near: 1,
-    far: 5e3,
-    perspective: {
-      aspect: void 0,
-      fov: 50
-    },
-    orthographic: {
-      left: void 0,
-      right: void 0,
-      top: void 0,
-      bottom: void 0
-    },
-    position: new import_three19.Vector3(50, 50, 50),
-    lookingAt: new import_three19.Vector3(0, 0, 0)
-  },
-  render: {
-    fpsLimit: 60,
-    stats: false,
-    antialias: true,
-    shade: true,
-    autoResize: true,
-    renderAlways: false
-  },
-  composer: {
-    enabled: true
-  },
-  controls: {
-    enabled: false
-  },
-  debug: {
-    grid: false,
-    axes: false
-  }
-});
-var Renderer = _Renderer;
 
 // src/skin/Skins.ts
 var Skins = class {
@@ -6512,7 +7101,7 @@ var Skins = class {
     return this.fromUsername(uuidOrUsername);
   }
   static async fromUuid(uuid) {
-    return this.getSkinProxySkinUrl(uuid);
+    return this.getMcProxySkinUrl(uuid);
   }
   static async fromUsername(username) {
     return this.usernameToUuid(username).then((uuid) => {
@@ -6539,7 +7128,7 @@ var Skins = class {
     return this.capeFromUsername(uuidOrUsername);
   }
   static async capeFromUuid(uuid) {
-    return this.getSkinProxyCapeUrl(uuid);
+    return this.getMcProxyCapeUrl(uuid);
   }
   static async capeFromUsername(username) {
     return this.usernameToUuid(username).then((uuid) => {
@@ -6549,19 +7138,31 @@ var Skins = class {
       return void 0;
     });
   }
-  static async capeFromCapesDev(uuid, capeType = "minecraft") {
-    return this.getCapesDev(uuid, capeType).then((cape) => {
-      if (cape) {
-        return cape == null ? void 0 : cape.stillImageUrl;
-      }
-      return void 0;
-    });
+  /** Returns a full static cape texture for a username or UUID. */
+  static async capeFromCapesDev(player, capeType = "minecraft") {
+    const cape = await this.getCapesDev(player, capeType);
+    return cape?.exists ? cape.imageUrls?.still?.full : void 0;
   }
   //</editor-fold>
   //<editor-fold desc="Helpers">
   static async usernameToUuid(username) {
-    return this.usernameToUuidSkinProxy(username);
+    return this.usernameToUuidMcProxy(username);
+  }
+  static async usernameToUuidMcProxy(username) {
+    return Requests.genericRequest({
+      baseURL: "https://mcproxy.dev",
+      url: "/uuid/" + username
+    }).then((res) => {
+      if (res.status === 200) {
+        return res.data["data"]["id"];
+      }
+      return void 0;
+    }).catch((err) => {
+      console.warn(err);
+      return void 0;
+    });
   }
+  /** @deprecated **/
   static async usernameToUuidSkinProxy(username) {
     return Requests.genericRequest({
       baseURL: "https://minecraft-skin-proxy.inventive.workers.dev",
@@ -6614,18 +7215,15 @@ var Skins = class {
       return void 0;
     });
   }
-  static async getCapesDev(uuid, type = "all") {
+  static async getCapesDev(player, type = "all") {
     return Requests.genericRequest({
       baseURL: "https://api.capes.dev",
-      url: "/load/" + uuid + "/" + type
+      url: "/load/" + encodeURIComponent(player) + "/" + encodeURIComponent(type)
     }).then((res) => {
       if (res.status === 200) {
         return res.data;
       }
       return void 0;
-    }).catch((err) => {
-      console.warn(err);
-      return void 0;
     });
   }
   static getCrafatarSkinUrl(uuid) {
@@ -6640,20 +7238,28 @@ var Skins = class {
   static getMineSkinPlayerSkinUrl(uuid) {
     return "https://mineskin.org/skin/player/" + uuid;
   }
+  /** @deprecated **/
   static getSkinProxySkinUrl(uuid) {
     return "https://minecraft-skin-proxy.inventive.workers.dev/skin/" + uuid;
   }
+  /** @deprecated **/
   static getSkinProxyCapeUrl(uuid) {
     return "https://minecraft-skin-proxy.inventive.workers.dev/cape/" + uuid;
   }
+  static getMcProxySkinUrl(uuid) {
+    return "https://mcproxy.dev/skin/" + uuid;
+  }
+  static getMcProxyCapeUrl(uuid) {
+    return "https://mcproxy.dev/cape/" + uuid;
+  }
   //</editor-fold>
 };
 
 // src/world/Chunk.ts
-var import_three22 = require("three");
+var import_three24 = require("three");
 
 // src/world/MineRenderWorld.ts
-var import_three21 = require("three");
+var import_three23 = require("three");
 var MineRenderWorld = class {
   constructor(scene) {
     this._size = 4;
@@ -6664,10 +7270,10 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three21.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three23.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three21.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three23.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const chunk = this.getChunkAt(posOrX);
     if (typeof chunk === "undefined") {
@@ -6678,10 +7284,10 @@ var MineRenderWorld = class {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three21.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three23.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three21.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three23.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     this.validatePosBounds(posOrX);
     const chunk = this.getOrCreateChunkAt(posOrX);
@@ -6709,7 +7315,7 @@ var MineRenderWorld = class {
     console.log("CHUNKS", this._chunks);
     for (let chunk of this._chunks.values()) {
       console.log("dispose chunk", chunk);
-      await (chunk == null ? void 0 : chunk.dispose());
+      await chunk?.dispose();
     }
     this._chunks.clear();
   }
@@ -6727,14 +7333,14 @@ var MineRenderWorld = class {
     return this._chunks[index];
   }
   static worldToScenePosition(pos) {
-    return new import_three21.Vector3(
+    return new import_three23.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new import_three21.Vector3(
+    return new import_three23.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -6763,7 +7369,7 @@ var MineRenderWorld = class {
 };
 
 // src/world/Chunk.ts
-var p12 = prefix("Chunk");
+var p11 = prefix("Chunk");
 var Chunk = class _Chunk {
   constructor(scene, x, y, z) {
     this._blocks = [];
@@ -6771,12 +7377,12 @@ var Chunk = class _Chunk {
     this.x = x;
     this.y = y;
     this.z = z;
-    let anchor = new import_three22.Object3D();
+    let anchor = new import_three24.Object3D();
     this._anchor = anchor;
     scene.add(anchor);
     anchor.position.set(this.x * 256 + 128 - 8, this.y * 256 + 128 - 8, this.z * 256 + 128 - 8);
     addBox3WireframeToObject(
-      new import_three22.Box3(new import_three22.Vector3(0, 0, 0), new import_three22.Vector3(256, 256, 256)),
+      new import_three24.Box3(new import_three24.Vector3(0, 0, 0), new import_three24.Vector3(256, 256, 256)),
       anchor,
       16776960,
       4
@@ -6784,10 +7390,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three22.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three24.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three22.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three24.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -6795,10 +7401,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three22.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three24.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three22.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three24.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -6815,7 +7421,7 @@ var Chunk = class _Chunk {
     const index = _Chunk.chunkPosToBlockIndex(pos);
     const current = this._blocks[index];
     if (typeof current !== "undefined") {
-      console.debug(p12, "deleting existing block at", pos, worldPos, index);
+      console.debug(p11, "deleting existing block at", pos, worldPos, index);
       current.object.removeFromScene();
       delete this._blocks[index];
     }
@@ -6844,7 +7450,7 @@ var Chunk = class _Chunk {
   }
   async clear() {
     let promises = [];
-    let pos = new import_three22.Vector3();
+    let pos = new import_three24.Vector3();
     for (let x = 0; x < 16; x++) {
       for (let z = 0; z < 16; z++) {
         for (let y = 0; y < 16; y++) {
@@ -6863,14 +7469,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three22.Vector3(
+    return new import_three24.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three22.Vector3(
+    return new import_three24.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z
@@ -6882,6 +7488,7 @@ var Chunk = class _Chunk {
   AXES,
   ArchiveAssetSource,
   AssetKey,
+  AssetLoadError,
   AssetLoader,
   AssetParser,
   AssetSource,
@@ -6891,9 +7498,9 @@ var Chunk = class _Chunk {
   BUILTIN_GENERATED,
   BasicAssetKey,
   BatchedExecutor,
-  BlockEntityModels,
   BlockObject,
   BlockStates,
+  BlockTints,
   BrowserArchiveProxy,
   CUBE_FACES,
   Caching,
@@ -6908,8 +7515,8 @@ var Chunk = class _Chunk {
   DISPLAY_POSITIONS,
   DefaultBlockStates,
   DisplayPosition,
+  DisplayTransforms,
   Entities,
-  EntityModels,
   EntityObject,
   Env,
   Geometries,
@@ -6939,6 +7546,7 @@ var Chunk = class _Chunk {
   OrbitControls,
   PersistentCache,
   Renderer,
+  RequestError,
   Requests,
   SKIN_PARTS,
   SceneInspector,
@@ -6948,6 +7556,7 @@ var Chunk = class _Chunk {
   SchematicParser,
   SkinObject,
   SkinPart,
+  SkinTextures,
   Skins,
   StructureParser,
   TextureAtlas,
@@ -6962,10 +7571,10 @@ var Chunk = class _Chunk {
   addWireframeToObject,
   applyElementRotation,
   applyGenericRotation,
-  applyModelPartRotation,
   axisToVec3,
   base64decode,
   base64encode,
+  capeTextureSizes,
   captureException,
   changeEvent,
   clampRotationDegrees,