minerender 2.1.0-alpha.2 → 2.1.0-alpha.21

package/dist/browser/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;
     };
-    exports.default = merge11;
+    exports.default = merge10;
   }
 });
 
@@ -135,6 +127,7 @@ __export(index_browser_exports, {
   AXES: () => AXES,
   ArchiveAssetSource: () => ArchiveAssetSource,
   AssetKey: () => AssetKey,
+  AssetLoadError: () => AssetLoadError,
   AssetLoader: () => AssetLoader,
   AssetParser: () => AssetParser,
   AssetSource: () => AssetSource,
@@ -147,6 +140,7 @@ __export(index_browser_exports, {
   BlockEntityModels: () => BlockEntityModels,
   BlockObject: () => BlockObject,
   BlockStates: () => BlockStates,
+  BlockTints: () => BlockTints,
   BrowserArchiveProxy: () => BrowserArchiveProxy,
   BrowserCache: () => BrowserCache,
   BrowserEnv: () => BrowserEnv,
@@ -192,6 +186,7 @@ __export(index_browser_exports, {
   OrbitControls: () => OrbitControls,
   PersistentCache: () => PersistentCache,
   Renderer: () => Renderer,
+  RequestError: () => RequestError,
   Requests: () => Requests,
   SKIN_PARTS: () => SKIN_PARTS,
   SceneInspector: () => SceneInspector,
@@ -308,17 +303,20 @@ var _PersistentCache = class _PersistentCache {
   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;
+_PersistentCache.VERSION = 2;
 var PersistentCache = _PersistentCache;
 
 // src/env/browser/BrowserCache.ts
@@ -419,7 +417,8 @@ var BrowserEnv = class {
   }
   openCache(name, version) {
     return new BrowserCache(import_localforage.default.createInstance({
-      name,
+      // IndexedDB schema upgrades retain records; each cache generation needs its own database.
+      name: name + version,
       version
     }));
   }
@@ -436,7 +435,7 @@ registerBrowserEnv();
 // 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;
@@ -444,7 +443,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);
@@ -547,7 +546,10 @@ 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 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 [
@@ -564,7 +566,11 @@ var Caching = class {
       this.rawModelCache,
       this.mergedModelCache,
       this.modelTextureAtlasCache,
-      this.blockStateCache
+      this.blockStateCache,
+      this.listAssetCache,
+      this.defaultBlockStatesCache,
+      this.blockTintCache,
+      this.entityModelsCache
     ];
   }
   static clear() {
@@ -575,8 +581,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) {
@@ -590,20 +596,25 @@ 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();
+_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();
+_Caching.listAssetCache = _Caching.createAssetCache();
+_Caching.defaultBlockStatesCache = _Caching.createAssetCache();
+_Caching.blockTintCache = _Caching.createAssetCache();
+_Caching.entityModelsCache = _Caching.createAssetCache();
+var Caching = _Caching;
 
 // src/Geometries.ts
 var Geometries = class _Geometries {
@@ -624,13 +635,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) {
@@ -641,9 +653,7 @@ function createCanvas(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";
@@ -653,198 +663,170 @@ 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 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;
+Requests.genericQueue = new RequestQueue();
+Requests.mcAssetRequestQueue = new RequestQueue();
 
 // src/WrappedImage.ts
 var WrappedImage = class {
@@ -882,10 +864,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);
@@ -895,7 +877,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);
   }
 };
 
@@ -909,29 +891,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 = createCanvas(info.width, info.height);
     const context = canvas.getContext("2d");
     context.drawImage(image, 0, 0);
@@ -942,11 +936,8 @@ var ImageLoader = class _ImageLoader {
     };
   }
   static async infoToData(info) {
-    const image = await _ImageLoader.loadAsync(info.src);
-    const canvas = createCanvas(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 });
@@ -961,38 +952,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 });
@@ -1014,38 +992,50 @@ var ImageLoader = class _ImageLoader {
 
 // src/texture/TextureLoader.ts
 var TextureLoader = class {
+  /** 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;
     return Textures.initTextureProps(texture);
   }
 };
+TextureLoader.failedTextures = /* @__PURE__ */ new WeakSet();
 
 // 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;
   }
@@ -1053,13 +1043,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);
     });
@@ -1075,26 +1071,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
     });
   }
@@ -1103,6 +1099,7 @@ var _Materials = class _Materials {
             uniform bool SHADE;
             
             varying vec2 vUv;
+            varying vec3 vTint;
             varying float light;
             varying float lift;
 
@@ -1115,7 +1112,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;
@@ -1133,6 +1134,7 @@ var _Materials = class _Materials {
                 }
                 
                 vUv = uv;
+                vTint = color;
                
                 #ifdef USE_INSTANCING
                     gl_Position = projectionMatrix * viewMatrix * modelMatrix * instanceMatrix * vec4(position, 1.0);
@@ -1154,12 +1156,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;
 
@@ -1173,16 +1177,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) }
@@ -1191,7 +1198,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) {
@@ -1201,6 +1208,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);
     });
@@ -1225,10 +1236,10 @@ _Materials.MISSING_TEXTURE_SRC = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA
 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);
@@ -1275,6 +1286,7 @@ 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?.namespace || DEFAULT_NAMESPACE;
@@ -1290,12 +1302,15 @@ var AssetKey = class _AssetKey extends BasicAssetKey {
       split.shift();
     }
     let path = split.join("/");
-    let extension = assetType === "textures" ? ".png" : origin?.assetType || ".json";
+    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__",
@@ -1305,12 +1320,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();
@@ -1320,10 +1335,10 @@ 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/ModelMerger.ts
@@ -1332,10 +1347,10 @@ var ModelMerger = class {
     const models = await this.collectAllParents(model);
     let merged = {};
     for (let parentModel of models) {
-      merged = (0, import_ts_deepmerge.default)(merged, parentModel);
+      merged = import_ts_deepmerge.default.withOptions({ mergeArrays: false }, merged, parentModel);
     }
-    merged = (0, import_ts_deepmerge.default)(merged, model);
-    merged.hierarchy = models.map((m) => m.parent).filter((p13) => `${p13}`);
+    merged = import_ts_deepmerge.default.withOptions({ mergeArrays: false }, merged, model);
+    merged.hierarchy = models.map((m) => m.parent).filter((p12) => `${p12}`);
     merged.hierarchy.push(`${merged.parent}`);
     return merged;
   }
@@ -1345,6 +1360,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);
@@ -1354,9 +1370,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";
@@ -1370,30 +1383,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 ?? (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?.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(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";
@@ -1432,19 +1480,15 @@ 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 ?? (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",
@@ -1452,11 +1496,16 @@ var BlockStates = class {
       "assets",
       ".json",
       DEFAULT_ROOT
-    ), "list" /* LIST */).then((r) => r?.files ?? []);
+    );
+    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();
@@ -1495,17 +1544,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 {
   /**
@@ -1527,82 +1570,213 @@ var AssetSource = class {
   constructor() {
   }
 };
-
-// src/nbt/NBTHelper.ts
-var NBTHelper = class {
-  static async fromBuffer(buffer) {
-    const prismarineNbt = await import("prismarine-nbt");
-    const { parsed, type, metadata } = await prismarineNbt.parse(buffer);
-    return parsed;
+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/assets/source/HostedAssetSource.ts
-var import_ts_deepmerge2 = __toESM(require_dist());
-var p3 = prefix("HostedAssetSource");
-var DEFAULT_OPTIONS = {
-  retryDefaults: true
-};
-var _HostedAssetSource = class _HostedAssetSource extends AssetSource {
-  async loadOrRetryWithDefaults(key, parser) {
-    const direct = await this.load(key, parser);
-    if (typeof direct !== "undefined") {
-      return direct;
-    }
-    if (key.namespace !== DEFAULT_NAMESPACE) {
-      console.info(p3, "Retrying", key, "with default namespace");
-      const namespaceKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, key.root);
-      const namespaced = await this.load(namespaceKey, parser);
-      if (typeof namespaced !== "undefined") {
-        return namespaced;
-      }
-      if (typeof key.root !== "undefined" && key.root !== DEFAULT_ROOT || typeof this.root !== "undefined" && this.root !== DEFAULT_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 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) {
-      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 rooted = await this.load(rootKey, parser);
-      if (typeof rooted !== "undefined") {
-        return rooted;
-      }
-    }
-    return void 0;
+// 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());
   }
-  async load(key, parser) {
+  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_three7 = require("three");
+function applyElementRotation(rotation, geometry) {
+  const origin = new import_three7.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 applyModelPartRotation(modelPart, geometry) {
+  const origin = new import_three7.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_three7.Vector3(1, 0, 0), toRadians(rotation));
+      break;
+    case "y" /* Y */:
+      obj.rotateOnAxis(new import_three7.Vector3(0, 1, 0), toRadians(rotation));
+      break;
+    case "z" /* Z */:
+      obj.rotateOnAxis(new import_three7.Vector3(0, 0, 1), toRadians(rotation));
+      break;
+  }
+}
+function addBox3WireframeToObject(box, obj, color = 16777215, w = 2) {
+  let size = new import_three7.Vector3();
+  box.getSize(size);
+  let boxGeo = new import_three7.BoxGeometry(size.x, size.y, size.z, 1, 1, 1);
+  let wireGeo = new import_three7.EdgesGeometry(boxGeo);
+  let wireMat = new import_three7.LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new import_three7.LineSegments(wireGeo, wireMat);
+  obj.add(wireframe);
+  let axes = new import_three7.AxesHelper(1);
+  obj.add(axes);
+}
+function addWireframeToObject(obj, color = 16777215, w = 2) {
+  let boxGeo = new import_three7.BoxGeometry(16, 16, 16, 1, 1, 1);
+  let wireGeo = new import_three7.EdgesGeometry(boxGeo);
+  let wireMat = new import_three7.LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new import_three7.LineSegments(wireGeo, wireMat);
+  obj.add(wireframe);
+  let axes = new import_three7.AxesHelper(1);
+  obj.add(axes);
+}
+function addWireframeToMesh(geo, mesh, color = 16777215, w = 2) {
+  let wireGeo = new import_three7.EdgesGeometry(geo);
+  let wireMat = new import_three7.LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new import_three7.LineSegments(wireGeo, wireMat);
+  mesh.add(wireframe);
+  let axes = new import_three7.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) {
+    const prismarineNbt = await import("prismarine-nbt");
+    const { parsed, type, metadata } = await prismarineNbt.parse(buffer);
+    return parsed;
+  }
+};
+
+// src/assets/source/HostedAssetSource.ts
+var import_ts_deepmerge2 = __toESM(require_dist());
+var p3 = prefix("HostedAssetSource");
+var DEFAULT_OPTIONS = {
+  retryDefaults: true
+};
+var _HostedAssetSource = class _HostedAssetSource extends AssetSource {
+  async loadOrRetryWithDefaults(key, parser) {
+    const direct = await this.load(key, parser);
+    if (typeof direct !== "undefined") {
+      return direct;
+    }
+    if (key.namespace !== DEFAULT_NAMESPACE) {
+      console.info(p3, "Retrying", key, "with default namespace");
+      const namespaceKey = new AssetKey(DEFAULT_NAMESPACE, key.path, key.assetType, key.type, key.rootType, key.extension, key.root);
+      const namespaced = await this.load(namespaceKey, parser);
+      if (typeof namespaced !== "undefined") {
+        return namespaced;
+      }
+      if (typeof key.root !== "undefined" && key.root !== DEFAULT_ROOT || typeof this.root !== "undefined" && this.root !== DEFAULT_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 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) {
+      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 rooted = await this.load(rootKey, parser);
+      if (typeof rooted !== "undefined") {
+        return rooted;
+      }
+    }
+    return void 0;
+  }
+  async load(key, parser) {
     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?.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 + "/" : ""}`;
@@ -1709,7 +1883,6 @@ var BrowserArchiveProxy = class {
 };
 
 // src/assets/source/archive/ArchiveAssetSource.ts
-var p4 = prefix("ArchiveAssetSource");
 var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
   constructor(archiveProxy) {
     super();
@@ -1728,74 +1901,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?.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?.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 + "/" : ""}`;
@@ -1803,18 +1933,17 @@ var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
 };
 
 // src/assets/AssetLoader.ts
-var import_ts_deepmerge3 = __toESM(require_dist());
-var p5 = prefix("AssetLoader");
+var p4 = prefix("AssetLoader");
 var _AssetLoader = class _AssetLoader {
   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);
@@ -1827,7 +1956,6 @@ var _AssetLoader = class _AssetLoader {
     return void 0;
   }
   static async getAll(key, parser) {
-    console.log(this._SOURCES);
     let promises = [];
     for (const source of this._SOURCES) {
       promises.push(source.source.get(key, parser));
@@ -1836,24 +1964,34 @@ 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;
@@ -1868,11 +2006,21 @@ var ModelTextures = class {
     return this._persistentMetaCache ?? (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();
@@ -2042,17 +2190,20 @@ var TextureAtlas = class {
 // src/model/ModelGenerator.ts
 var ModelGenerator = class {
   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
@@ -2063,11 +2214,19 @@ var ModelGenerator = class {
 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_three8.Vector3(0, 0, -1), new import_three8.Vector3(0, -1, 0)],
+  west: [new import_three8.Vector3(0, 0, 1), new import_three8.Vector3(0, -1, 0)],
+  up: [new import_three8.Vector3(1, 0, 0), new import_three8.Vector3(0, 0, 1)],
+  down: [new import_three8.Vector3(1, 0, 0), new import_three8.Vector3(0, 0, -1)],
+  south: [new import_three8.Vector3(1, 0, 0), new import_three8.Vector3(0, -1, 0)],
+  north: [new import_three8.Vector3(-1, 0, 0), new import_three8.Vector3(0, -1, 0)]
+};
 var UVMapper = class {
   static makeUv(uvCoord, originalTextureSize, actualTextureSize) {
     if (uvCoord === 0) return 0;
@@ -2165,6 +2324,42 @@ var UVMapper = class {
   static facesToUv(faces, originalTextureSize, actualTextureSize) {
     return new import_three8.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();
     return Caching.modelTextureAtlasCache.get(keyStr, (k) => {
@@ -2240,7 +2435,7 @@ var UVMapper = class {
     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 = [];
@@ -2254,7 +2449,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);
@@ -2266,7 +2461,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 = {};
@@ -2286,7 +2481,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");
@@ -2341,10 +2536,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];
@@ -2352,7 +2547,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) {
       }
@@ -2370,17 +2565,13 @@ 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];
-            }
+            const faceTexture = face.texture.substr(1);
+            const texPosition = positions[faceTexture] || [0, 0];
+            const texSize = sizes[faceTexture] || [16, 16];
             let texPosV = new import_three8.Vector2(texPosition[0], texPosition[1]);
             const [tl, tr, bl, br] = this.expandAndRotateMcUvs(face.uv, face.rotation, texSize[0], texSize[1]);
             tl.add(texPosV);
@@ -2412,7 +2603,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;
   }
@@ -2550,17 +2741,20 @@ function shutdown() {
 }
 
 // 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 */);
+    return Caching.entityModelsCache.get(key.serialize(), () => {
+      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 */);
+    return Caching.entityModelsCache.get(key.serialize(), () => {
+      return AssetLoader.get(key, "json" /* JSON */);
+    });
   }
   // BlockEntity names are hardcoded
   static async getBlockList() {
@@ -2606,12 +2800,6 @@ var Entities = class {
     };
   }
 };
-__decorateClass([
-  (0, import_typescript_memoize3.Memoize)()
-], Entities, "getBlockEntityModels", 1);
-__decorateClass([
-  (0, import_typescript_memoize3.Memoize)()
-], Entities, "getEntityModels", 1);
 var EntityModels = class {
 };
 var BlockEntityModels = class {
@@ -2675,8 +2863,8 @@ var MineRenderError = class _MineRenderError extends Error {
 };
 
 // src/renderer/SceneObject.ts
-var import_ts_deepmerge4 = __toESM(require_dist());
-var p7 = prefix("SceneObject");
+var import_ts_deepmerge3 = __toESM(require_dist());
+var p6 = prefix("SceneObject");
 var _SceneObject = class _SceneObject extends import_three9.Object3D {
   constructor(options) {
     super();
@@ -2684,7 +2872,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     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);
   }
   set scene(scene) {
@@ -2778,6 +2966,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
   }
   createInstancedMesh(name, geometry, material, count) {
     const mesh = new import_three9.InstancedMesh(geometry, material, count);
+    mesh.count = 0;
     if (name) {
       mesh.name = `mesh:${name}`;
     }
@@ -2855,9 +3044,13 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
     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);
+    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++;
@@ -3033,7 +3226,7 @@ var _SceneObject = class _SceneObject extends import_three9.Object3D {
   }
   //</editor-fold>
 };
-_SceneObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, {
+_SceneObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge3.default)({}, {
   instanceMeshes: true,
   maxInstanceCount: 50,
   mergeMeshes: true,
@@ -3045,16 +3238,16 @@ function isSceneObject(obj) {
 }
 
 // src/entity/scene/EntityObject.ts
-var import_ts_deepmerge5 = __toESM(require_dist());
+var import_ts_deepmerge4 = __toESM(require_dist());
 var import_three11 = require("three");
-var THREE2 = __toESM(require("three"));
+var THREE3 = __toESM(require("three"));
 var EntityObject = class 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)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
   }
   async init() {
     this.createMeshes();
@@ -3063,8 +3256,8 @@ var EntityObject = class extends SceneObject {
   dispose() {
     super.dispose();
   }
-  async loadTextures() {
-    this.imageData = await ModelTextures.get(new AssetKey(
+  get textureKey() {
+    return new AssetKey(
       this.entity.key?.namespace ?? DEFAULT_NAMESPACE,
       this.entity.key.path,
       //TODO: texture may differ from entity name; most of them are in subdirectories for multiple variants etc.
@@ -3072,7 +3265,10 @@ var EntityObject = class extends SceneObject {
       "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) {
@@ -3091,8 +3287,8 @@ var EntityObject = class extends SceneObject {
         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));
+        cubeGeo.applyMatrix4(new THREE3.Matrix4().makeTranslation(w / 2, h / 2, l / 2));
+        cubeGeo.applyMatrix4(new THREE3.Matrix4().makeTranslation(cube.minX, cube.minY, cube.minZ));
         applyModelPartRotation(part, cubeGeo);
         const mesh = this.createMesh(partName, cubeGeo, mat);
         partAnchor.add(mesh);
@@ -3105,23 +3301,26 @@ var EntityObject = class extends SceneObject {
     this.meshesCreated = true;
   }
   async applyTextures() {
-    const textureAsset = await ModelTextures.preload(new AssetKey(
-      this.entity.key?.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;
-      });
-    }
+    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, {});
+EntityObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS, {});
 function isEntityObject(obj) {
   return obj.isEntityObject;
 }
@@ -3133,7 +3332,7 @@ var GuiObject = class extends SceneObject {
 
 // src/inspector/SceneInspector.ts
 var import_three12 = require("three");
-var p8 = prefix("SceneInspector");
+var p7 = prefix("SceneInspector");
 var help = "<span>Ctrl+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
@@ -3202,7 +3401,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) {
@@ -3500,7 +3699,7 @@ var SceneStatsDisplay = class {
 };
 
 // src/instance/InstanceManager.ts
-var p9 = prefix("InstanceManager");
+var p8 = prefix("InstanceManager");
 var InstanceManager = class {
   constructor() {
     this.isInstanceManager = true;
@@ -3508,7 +3707,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;
@@ -3517,13 +3716,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) {
@@ -3576,20 +3779,105 @@ function isQuadArray(obj) {
   return Array.isArray(obj) && obj.length === 4;
 }
 
-// src/model/scene/ModelObject.ts
-var import_three15 = require("three");
+// 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/three/BufferGeometryUtils.js
-var import_three14 = require("three");
-function computeTangents(geometry) {
-  geometry.computeTangents();
-  console.warn("THREE.BufferGeometryUtils: .computeTangents() has been removed. Use BufferGeometry.computeTangents() instead.");
-}
-function mergeBufferGeometries(geometries, useGroups = false) {
-  const isIndexed = geometries[0].index !== null;
-  const attributesUsed = new Set(Object.keys(geometries[0].attributes));
-  const morphAttributesUsed = new Set(Object.keys(geometries[0].morphAttributes));
-  const attributes = {};
+// 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");
+
+// src/three/BufferGeometryUtils.js
+var import_three14 = require("three");
+function computeTangents(geometry) {
+  geometry.computeTangents();
+  console.warn("THREE.BufferGeometryUtils: .computeTangents() has been removed. Use BufferGeometry.computeTangents() instead.");
+}
+function mergeBufferGeometries(geometries, useGroups = false) {
+  const isIndexed = geometries[0].index !== null;
+  const attributesUsed = new Set(Object.keys(geometries[0].attributes));
+  const morphAttributesUsed = new Set(Object.keys(geometries[0].morphAttributes));
+  const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
   const mergedGeometry = new import_three14.BufferGeometry();
@@ -4112,15 +4400,16 @@ function computeMorphedAttributes(object) {
 }
 
 // src/model/scene/ModelObject.ts
-var import_ts_deepmerge6 = __toESM(require_dist());
-var p10 = prefix("ModelObject");
+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);
   }
   async init() {
@@ -4147,6 +4436,23 @@ var _ModelObject = class _ModelObject extends SceneObject {
       if (this.atlas.model.elements) {
         this.atlas.model.elements?.forEach((el) => {
           const elGeo = this._getBoxGeometryFromElement(el).clone();
+          if (this.options.uvLockRotation) {
+            UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three15.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_three15.Color(tint);
+              for (let vertex = 0; vertex < 4; vertex++) {
+                color.toArray(colors, (faceIndex * 4 + vertex) * 3);
+              }
+            }
+            elGeo.setAttribute("color", new import_three15.BufferAttribute(colors, 3));
+          }
           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 (el.rotation) {
@@ -4163,10 +4469,10 @@ 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;
@@ -4203,6 +4509,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) {
@@ -4218,16 +4525,26 @@ var _ModelObject = class _ModelObject extends SceneObject {
     }
   }
 };
-_ModelObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge6.default)({}, SceneObject.DEFAULT_OPTIONS, {});
+_ModelObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge5.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_ts_deepmerge6 = __toESM(require_dist());
 var import_three16 = require("three");
-var p11 = prefix("BlockObject");
+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);
@@ -4241,11 +4558,11 @@ 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 ?? {});
   }
   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) {
@@ -4256,15 +4573,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 {
@@ -4321,55 +4632,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));
-          }
         }
       }
     }
@@ -4399,11 +4666,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) {
@@ -4411,28 +4688,25 @@ 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_three16.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 model = await Models.getMerged(AssetKey.parse("models", variant.model));
+    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() {
@@ -4522,15 +4796,16 @@ 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, {
+_BlockObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge6.default)({}, ModelObject.DEFAULT_OPTIONS, {
   applyDefaultState: true
 });
 var BlockObject = _BlockObject;
@@ -4580,7 +4855,7 @@ var StructureParser = class {
 
 // src/renderer/MineRenderScene.ts
 var import_three17 = require("three");
-var import_ts_deepmerge9 = __toESM(require_dist());
+var import_ts_deepmerge8 = __toESM(require_dist());
 
 // src/skin/SkinPart.ts
 var SkinPart = /* @__PURE__ */ ((SkinPart2) => {
@@ -5311,7 +5586,7 @@ var slimSkinGeometries = {
 };
 
 // src/skin/scene/SkinObject.ts
-var import_ts_deepmerge8 = __toESM(require_dist());
+var import_ts_deepmerge7 = __toESM(require_dist());
 var SkinObject = class extends SceneObject {
   constructor(options) {
     super();
@@ -5319,7 +5594,7 @@ var SkinObject = class extends SceneObject {
     this.legacy = false;
     this.skinTextureWidth = 64;
     this.skinTextureHeight = 64;
-    this.options = (0, import_ts_deepmerge8.default)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
+    this.options = (0, import_ts_deepmerge7.default)({}, SceneObject.DEFAULT_OPTIONS, options ?? {});
   }
   async init() {
     this.createMeshes();
@@ -5436,7 +5711,7 @@ var _MineRenderScene = class _MineRenderScene extends import_three17.Scene {
         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 ?? {});
   }
   add(...objects) {
     for (const object of objects) {
@@ -5494,7 +5769,13 @@ var _MineRenderScene = class _MineRenderScene extends import_three17.Scene {
     const obj = await objectSupplier();
     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 { uvLockRotation, tints } = obj.options;
+        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();
@@ -5532,1106 +5813,1163 @@ 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)({}, {});
+_MineRenderScene.DEFAULT_OPTIONS = (0, import_ts_deepmerge8.default)({}, {});
 var MineRenderScene = _MineRenderScene;
 function isMineRenderScene(obj) {
   return obj.isMineRenderScene;
 }
 
 // src/renderer/Renderer.ts
-var import_three18 = require("three");
-var import_ts_deepmerge10 = __toESM(require_dist());
+var import_three19 = require("three");
+var import_ts_deepmerge9 = __toESM(require_dist());
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
-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 = [];
-    this._eventDispatchers = /* @__PURE__ */ new Map();
-    this._changeListener = () => {
-      this._dirty = true;
+
+// src/three/OrbitControls.js
+var import_three18 = require("three");
+var _changeEvent = { type: "change" };
+var _startEvent = { type: "start" };
+var _endEvent = { type: "end" };
+var OrbitControls = class extends import_three18.EventDispatcher {
+  constructor(object, domElement) {
+    super();
+    if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
+    if (domElement === document) console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.');
+    this.object = object;
+    this.domElement = domElement;
+    this.domElement.style.touchAction = "none";
+    this.enabled = true;
+    this.target = new import_three18.Vector3();
+    this.minDistance = 0;
+    this.maxDistance = Infinity;
+    this.minZoom = 0;
+    this.maxZoom = Infinity;
+    this.minPolarAngle = 0;
+    this.maxPolarAngle = Math.PI;
+    this.minAzimuthAngle = -Infinity;
+    this.maxAzimuthAngle = Infinity;
+    this.enableDamping = false;
+    this.dampingFactor = 0.05;
+    this.enableZoom = true;
+    this.zoomSpeed = 1;
+    this.enableRotate = true;
+    this.rotateSpeed = 1;
+    this.enablePan = true;
+    this.panSpeed = 1;
+    this.screenSpacePanning = true;
+    this.keyPanSpeed = 7;
+    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.target0 = this.target.clone();
+    this.position0 = this.object.position.clone();
+    this.zoom0 = this.object.zoom;
+    this._domElementKeyEvents = null;
+    this.getPolarAngle = function() {
+      return spherical.phi;
     };
-    this.options = (0, import_ts_deepmerge10.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._scene = this.createScene();
-    this._camera = this.createCamera();
-    this._renderer = this.createRenderer();
-    this._composer = this.createComposer();
-    if (this.options.render.stats) {
-      this._stats = new import_stats.default();
-      document.body.appendChild(this._stats.dom);
-    }
-    this.init();
-  }
-  //<editor-fold desc="INIT">
-  createScene() {
-    return new MineRenderScene();
-  }
-  createCamera() {
-    switch (this.options.camera.type) {
-      case "perspective":
-      default:
-        return new import_three18.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_three18.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,
-          this.options.camera.orthographic.bottom ?? this.viewHeight / -2,
-          this.options.camera.near,
-          this.options.camera.far
-        );
-    }
-  }
-  createRenderer() {
-    const renderer = new import_three18.WebGLRenderer({
-      antialias: this.options.render.antialias,
-      alpha: true,
-      powerPreference: "high-performance",
-      depth: true
-    });
-    renderer.setClearColor(0, 0);
-    renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three18.PCFSoftShadowMap;
-    renderer.outputEncoding = import_three18.LinearEncoding;
-    renderer.setSize(this.viewWidth, this.viewHeight);
-    return renderer;
-  }
-  createComposer() {
-    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;
-  }
-  //</editor-fold>
-  init() {
-    if (this._disposed) return;
-    if (typeof window["__THREE_DEVTOOLS__"] !== "undefined") {
-      window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
-    }
-    if (this.options.debug.grid) {
-      const gridHelper = new import_three18.GridHelper(128, 16);
-      this._debugHelpers.push(gridHelper);
-      this.scene.add(gridHelper);
-      const gridHelper2 = new import_three18.GridHelper(128, 16);
-      this._debugHelpers.push(gridHelper2);
-      gridHelper2.rotation.x = 90 * (Math.PI / 180);
-      this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three18.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_three18.AxesHelper(64);
-      this._debugHelpers.push(axesHelper);
-      this.scene.add(axesHelper);
-    }
-    if (this.options.camera.position) {
-      if (isVector3(this.options.camera.position)) {
-        this.camera.position.set(this.options.camera.position.x, this.options.camera.position.y, this.options.camera.position.z);
-      } else if (isTripleArray(this.options.camera.position)) {
-        this.camera.position.set(this.options.camera.position[0], this.options.camera.position[1], this.options.camera.position[2]);
-      }
-    }
-    if (this.options.camera.lookingAt) {
-      if (isVector3(this.options.camera.lookingAt)) {
-        this.camera.lookAt(this.options.camera.lookingAt);
-      } else if (isTripleArray(this.options.camera.lookingAt)) {
-        this.camera.lookAt(this.options.camera.lookingAt[0], this.options.camera.lookingAt[1], this.options.camera.lookingAt[2]);
-      }
-    }
-    if (this.options.render.autoResize && !this._resizeListener) {
-      this._resizeListener = () => {
-        this.resize(this.viewWidth, this.viewHeight);
-      };
-      window.addEventListener("resize", this._resizeListener);
-    }
-  }
-  get element() {
-    return this._element;
-  }
-  appendTo(element) {
-    if (this._disposed) return;
-    this._element = element;
-    this._element.appendChild(this.renderer.domElement);
-    if (this.viewWidth == 0) {
-      console.warn("0 element width");
-    }
-    if (this.viewHeight == 0) {
-      console.warn("0 element height");
-    }
-    this.resize(this.viewWidth, this.viewHeight);
-  }
-  /**
-   * Redraws when the dispatcher emits the selected event. Registering the same pair twice has no effect.
-   * The renderer removes its listener on disposal; the caller retains ownership of the dispatcher.
-   */
-  registerEventDispatcher(dispatcher, changeEvent2 = "change") {
-    if (this._disposed) return;
-    let events = this._eventDispatchers.get(dispatcher);
-    if (!events) {
-      events = /* @__PURE__ */ new Set();
-      this._eventDispatchers.set(dispatcher, events);
-    }
-    if (events.has(changeEvent2)) return;
-    events.add(changeEvent2);
-    dispatcher.addEventListener(changeEvent2, this._changeListener);
-  }
-  resize(width, height) {
-    if (this._disposed) return;
-    if (isPerspectiveCamera(this.camera)) {
-      this.camera.aspect = width / height;
-      this.camera.updateProjectionMatrix();
-    } else if (isOrthographicCamera(this.camera)) {
-      this.camera.left = width / -2;
-      this.camera.right = width / 2;
-      this.camera.top = height / 2;
-      this.camera.bottom = height / -2;
-      this.camera.updateProjectionMatrix();
+    this.getAzimuthalAngle = function() {
+      return spherical.theta;
+    };
+    this.getDistance = function() {
+      return this.object.position.distanceTo(this.target);
+    };
+    this.saveState = function() {
+      scope.target0.copy(scope.target);
+      scope.position0.copy(scope.object.position);
+      scope.zoom0 = scope.object.zoom;
+    };
+    this.reset = function() {
+      scope.target.copy(scope.target0);
+      scope.object.position.copy(scope.position0);
+      scope.object.zoom = scope.zoom0;
+      scope.object.updateProjectionMatrix();
+      scope.dispatchEvent(_changeEvent);
+      scope.update();
+      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 quatInverse = quat.clone().invert();
+      const lastPosition = new import_three18.Vector3();
+      const lastQuaternion = new import_three18.Quaternion();
+      const twoPI = 2 * Math.PI;
+      return function update() {
+        const position = scope.object.position;
+        offset.copy(position).sub(scope.target);
+        offset.applyQuaternion(quat);
+        spherical.setFromVector3(offset);
+        if (scope.autoRotate && state === STATE.NONE) {
+          rotateLeft(getAutoRotationAngle());
+        }
+        if (scope.enableDamping) {
+          spherical.theta += sphericalDelta.theta * scope.dampingFactor;
+          spherical.phi += sphericalDelta.phi * scope.dampingFactor;
+        } else {
+          spherical.theta += sphericalDelta.theta;
+          spherical.phi += sphericalDelta.phi;
+        }
+        let min = scope.minAzimuthAngle;
+        let max = scope.maxAzimuthAngle;
+        if (isFinite(min) && isFinite(max)) {
+          if (min < -Math.PI) min += twoPI;
+          else if (min > Math.PI) min -= twoPI;
+          if (max < -Math.PI) max += twoPI;
+          else if (max > Math.PI) max -= twoPI;
+          if (min <= max) {
+            spherical.theta = Math.max(min, Math.min(max, spherical.theta));
+          } else {
+            spherical.theta = spherical.theta > (min + max) / 2 ? Math.max(min, spherical.theta) : Math.min(max, spherical.theta);
+          }
+        }
+        spherical.phi = Math.max(scope.minPolarAngle, Math.min(scope.maxPolarAngle, spherical.phi));
+        spherical.makeSafe();
+        spherical.radius *= scale;
+        spherical.radius = Math.max(scope.minDistance, Math.min(scope.maxDistance, spherical.radius));
+        if (scope.enableDamping === true) {
+          scope.target.addScaledVector(panOffset, scope.dampingFactor);
+        } else {
+          scope.target.add(panOffset);
+        }
+        offset.setFromSpherical(spherical);
+        offset.applyQuaternion(quatInverse);
+        position.copy(scope.target).add(offset);
+        scope.object.lookAt(scope.target);
+        if (scope.enableDamping === true) {
+          sphericalDelta.theta *= 1 - scope.dampingFactor;
+          sphericalDelta.phi *= 1 - scope.dampingFactor;
+          panOffset.multiplyScalar(1 - scope.dampingFactor);
+        } else {
+          sphericalDelta.set(0, 0, 0);
+          panOffset.set(0, 0, 0);
+        }
+        scale = 1;
+        if (zoomChanged || lastPosition.distanceToSquared(scope.object.position) > EPS || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS) {
+          scope.dispatchEvent(_changeEvent);
+          lastPosition.copy(scope.object.position);
+          lastQuaternion.copy(scope.object.quaternion);
+          zoomChanged = false;
+          return true;
+        }
+        return false;
+      };
+    }();
+    this.dispose = function() {
+      scope.domElement.removeEventListener("contextmenu", onContextMenu);
+      scope.domElement.removeEventListener("pointerdown", onPointerDown);
+      scope.domElement.removeEventListener("pointercancel", onPointerCancel);
+      scope.domElement.removeEventListener("wheel", onMouseWheel);
+      scope.domElement.removeEventListener("pointermove", onPointerMove);
+      scope.domElement.removeEventListener("pointerup", onPointerUp);
+      if (scope._domElementKeyEvents !== null) {
+        scope._domElementKeyEvents.removeEventListener("keydown", onKeyDown);
+      }
+    };
+    const scope = this;
+    const STATE = {
+      NONE: -1,
+      ROTATE: 0,
+      DOLLY: 1,
+      PAN: 2,
+      TOUCH_ROTATE: 3,
+      TOUCH_PAN: 4,
+      TOUCH_DOLLY_PAN: 5,
+      TOUCH_DOLLY_ROTATE: 6
+    };
+    let state = STATE.NONE;
+    const EPS = 1e-6;
+    const spherical = new import_three18.Spherical();
+    const sphericalDelta = new import_three18.Spherical();
+    let scale = 1;
+    const panOffset = new import_three18.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 pointers = [];
+    const pointerPositions = {};
+    function getAutoRotationAngle() {
+      return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
     }
-    this.renderer.setSize(width, height);
-    this.composer.setSize(width, height);
-    this._dirty = true;
-  }
-  //<editor-fold desc="RENDER">
-  get dirty() {
-    return this._dirty || this.scene.dirty;
-  }
-  set dirty(dirty) {
-    this._dirty = dirty;
-    this.scene.dirty = dirty;
-  }
-  start() {
-    if (this._disposed) return;
-    this.stop();
-    this.renderer.setAnimationLoop(this._animationLoop);
-  }
-  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;
-  }
-  /**
-   * Stops rendering and releases owned resources. Repeated calls have no effect, and a disposed
-   * renderer cannot be restarted. Scene objects are detached; shared assets and caller-owned
-   * controls must be managed by their owners.
-   */
-  dispose() {
-    if (this._disposed) return;
-    this.stop();
-    this._disposed = true;
-    if (this._resizeListener) {
-      window.removeEventListener("resize", this._resizeListener);
-      this._resizeListener = void 0;
+    function getZoomScale() {
+      return Math.pow(0.95, scope.zoomSpeed);
     }
-    for (const [dispatcher, events] of this._eventDispatchers) {
-      for (const event of events) {
-        dispatcher.removeEventListener(event, this._changeListener);
-      }
+    function rotateLeft(angle) {
+      sphericalDelta.theta -= angle;
     }
-    this._eventDispatchers.clear();
-    this._stats?.dom.remove();
-    this._stats = void 0;
-    this.renderer.domElement.remove();
-    this._element = void 0;
-    this.scene.clear();
-    for (const helper of this._debugHelpers) {
-      helper.geometry.dispose();
-      const materials = Array.isArray(helper.material) ? helper.material : [helper.material];
-      for (const material of materials) {
-        material.dispose();
-      }
+    function rotateUp(angle) {
+      sphericalDelta.phi -= angle;
     }
-    this._debugHelpers.length = 0;
-    this.composer.dispose();
-    this.renderer.dispose();
-    this.renderer.forceContextLoss();
-  }
-  animate(t) {
-    if (this._disposed) return;
-    if (this._stats) {
-      this._stats.begin();
+    const panLeft = function() {
+      const v = new import_three18.Vector3();
+      return function panLeft2(distance, objectMatrix) {
+        v.setFromMatrixColumn(objectMatrix, 0);
+        v.multiplyScalar(-distance);
+        panOffset.add(v);
+      };
+    }();
+    const panUp = function() {
+      const v = new import_three18.Vector3();
+      return function panUp2(distance, objectMatrix) {
+        if (scope.screenSpacePanning === true) {
+          v.setFromMatrixColumn(objectMatrix, 1);
+        } else {
+          v.setFromMatrixColumn(objectMatrix, 0);
+          v.crossVectors(scope.object.up, v);
+        }
+        v.multiplyScalar(distance);
+        panOffset.add(v);
+      };
+    }();
+    const pan = function() {
+      const offset = new import_three18.Vector3();
+      return function pan2(deltaX, deltaY) {
+        const element = scope.domElement;
+        if (scope.object.isPerspectiveCamera) {
+          const position = scope.object.position;
+          offset.copy(position).sub(scope.target);
+          let targetDistance = offset.length();
+          targetDistance *= Math.tan(scope.object.fov / 2 * Math.PI / 180);
+          panLeft(2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix);
+          panUp(2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix);
+        } else if (scope.object.isOrthographicCamera) {
+          panLeft(deltaX * (scope.object.right - scope.object.left) / scope.object.zoom / element.clientWidth, scope.object.matrix);
+          panUp(deltaY * (scope.object.top - scope.object.bottom) / scope.object.zoom / element.clientHeight, scope.object.matrix);
+        } else {
+          console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.");
+          scope.enablePan = false;
+        }
+      };
+    }();
+    function dollyOut(dollyScale) {
+      if (scope.object.isPerspectiveCamera) {
+        scale /= dollyScale;
+      } else if (scope.object.isOrthographicCamera) {
+        scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom * dollyScale));
+        scope.object.updateProjectionMatrix();
+        zoomChanged = true;
+      } else {
+        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
+        scope.enableZoom = false;
+      }
     }
-    if (this.dirty || this.options.render.renderAlways) {
-      if (this.options.composer.enabled) {
-        this.composer.render();
+    function dollyIn(dollyScale) {
+      if (scope.object.isPerspectiveCamera) {
+        scale *= dollyScale;
+      } else if (scope.object.isOrthographicCamera) {
+        scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / dollyScale));
+        scope.object.updateProjectionMatrix();
+        zoomChanged = true;
       } else {
-        this.renderer.render(this.scene, this.camera);
+        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
+        scope.enableZoom = false;
       }
     }
-    this.dirty = false;
-    if (this._stats) {
-      this._stats.end();
+    function handleMouseDownRotate(event) {
+      rotateStart.set(event.clientX, event.clientY);
     }
-  }
-  //</editor-fold>
-  toImage() {
-    return this.renderer.domElement.toDataURL();
-  }
-  ///
-  get attachedToBody() {
-    return this.element === document.body;
-  }
-  get viewWidth() {
-    return this.attachedToBody ? window.innerWidth : this.element?.offsetWidth || 0;
-  }
-  get viewHeight() {
-    return this.attachedToBody ? window.innerHeight : this.element?.offsetHeight || 0;
-  }
-  get scene() {
-    return this._scene;
-  }
-  get camera() {
-    return this._camera;
-  }
-  get renderer() {
-    return this._renderer;
-  }
-  get composer() {
-    return this._composer;
-  }
-  ///
-};
-_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_three18.Vector3(50, 50, 50),
-    lookingAt: new import_three18.Vector3(0, 0, 0)
-  },
-  render: {
-    fpsLimit: 60,
-    stats: false,
-    antialias: true,
-    shade: true,
-    autoResize: true,
-    renderAlways: false
-  },
-  composer: {
-    enabled: true
-  },
-  debug: {
-    grid: false,
-    axes: false
-  }
-});
-var Renderer = _Renderer;
-
-// src/skin/Skins.ts
-var Skins = class {
-  //<editor-fold desc="Skins">
-  static async fromUuidOrUsername(uuidOrUsername) {
-    if (uuidOrUsername.length === 32 || uuidOrUsername.length === 36) {
-      return this.fromUuid(uuidOrUsername);
+    function handleMouseDownDolly(event) {
+      dollyStart.set(event.clientX, event.clientY);
     }
-    return this.fromUsername(uuidOrUsername);
-  }
-  static async fromUuid(uuid) {
-    return this.getSkinProxySkinUrl(uuid);
-  }
-  static async fromUsername(username) {
-    return this.usernameToUuid(username).then((uuid) => {
-      if (uuid) {
-        return this.fromUuid(uuid);
+    function handleMouseDownPan(event) {
+      panStart.set(event.clientX, event.clientY);
+    }
+    function handleMouseMoveRotate(event) {
+      rotateEnd.set(event.clientX, event.clientY);
+      rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
+      const element = scope.domElement;
+      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
+      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
+      rotateStart.copy(rotateEnd);
+      scope.update();
+    }
+    function handleMouseMoveDolly(event) {
+      dollyEnd.set(event.clientX, event.clientY);
+      dollyDelta.subVectors(dollyEnd, dollyStart);
+      if (dollyDelta.y > 0) {
+        dollyOut(getZoomScale());
+      } else if (dollyDelta.y < 0) {
+        dollyIn(getZoomScale());
       }
-      return void 0;
-    });
-  }
-  static async fromMineSkin(mineskinId) {
-    return this.getMineSkin(mineskinId).then((mineskin) => {
-      if (mineskin) {
-        return mineskin["data"]["texture"]["value"]["urls"]["skins"];
+      dollyStart.copy(dollyEnd);
+      scope.update();
+    }
+    function handleMouseMovePan(event) {
+      panEnd.set(event.clientX, event.clientY);
+      panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
+      pan(panDelta.x, panDelta.y);
+      panStart.copy(panEnd);
+      scope.update();
+    }
+    function handleMouseUp() {
+    }
+    function handleMouseWheel(event) {
+      if (event.deltaY < 0) {
+        dollyIn(getZoomScale());
+      } else if (event.deltaY > 0) {
+        dollyOut(getZoomScale());
       }
-      return void 0;
-    });
-  }
-  //</editor-fold>
-  //<editor-fold desc="Capes">
-  static async capeFromUuidOrUsername(uuidOrUsername) {
-    if (uuidOrUsername.length === 32 || uuidOrUsername.length === 36) {
-      return this.capeFromUuid(uuidOrUsername);
+      scope.update();
     }
-    return this.capeFromUsername(uuidOrUsername);
-  }
-  static async capeFromUuid(uuid) {
-    return this.getSkinProxyCapeUrl(uuid);
-  }
-  static async capeFromUsername(username) {
-    return this.usernameToUuid(username).then((uuid) => {
-      if (uuid) {
-        return this.capeFromUuid(uuid);
+    function handleKeyDown(event) {
+      let needsUpdate = false;
+      switch (event.code) {
+        case scope.keys.UP:
+          pan(0, scope.keyPanSpeed);
+          needsUpdate = true;
+          break;
+        case scope.keys.BOTTOM:
+          pan(0, -scope.keyPanSpeed);
+          needsUpdate = true;
+          break;
+        case scope.keys.LEFT:
+          pan(scope.keyPanSpeed, 0);
+          needsUpdate = true;
+          break;
+        case scope.keys.RIGHT:
+          pan(-scope.keyPanSpeed, 0);
+          needsUpdate = true;
+          break;
       }
-      return void 0;
-    });
-  }
-  static async capeFromCapesDev(uuid, capeType = "minecraft") {
-    return this.getCapesDev(uuid, capeType).then((cape) => {
-      if (cape) {
-        return cape?.stillImageUrl;
+      if (needsUpdate) {
+        event.preventDefault();
+        scope.update();
       }
-      return void 0;
-    });
-  }
-  //</editor-fold>
-  //<editor-fold desc="Helpers">
-  static async usernameToUuid(username) {
-    return this.usernameToUuidSkinProxy(username);
-  }
-  static async usernameToUuidSkinProxy(username) {
-    return Requests.genericRequest({
-      baseURL: "https://minecraft-skin-proxy.inventive.workers.dev",
-      url: "/uuid/" + username
-    }).then((res) => {
-      if (res.status === 200) {
-        return res.data["id"];
+    }
+    function handleTouchStartRotate() {
+      if (pointers.length === 1) {
+        rotateStart.set(pointers[0].pageX, pointers[0].pageY);
+      } else {
+        const x = 0.5 * (pointers[0].pageX + pointers[1].pageX);
+        const y = 0.5 * (pointers[0].pageY + pointers[1].pageY);
+        rotateStart.set(x, y);
       }
-      return void 0;
-    }).catch((err) => {
-      console.warn(err);
-      return void 0;
-    });
-  }
-  static async usernameToUuidMineTools(username) {
-    return Requests.genericRequest({
-      baseURL: "https://api.minetools.eu",
-      url: "/uuid/" + username
-    }).then((res) => {
-      if (res.status === 200) {
-        return res.data["id"];
+    }
+    function handleTouchStartPan() {
+      if (pointers.length === 1) {
+        panStart.set(pointers[0].pageX, pointers[0].pageY);
+      } else {
+        const x = 0.5 * (pointers[0].pageX + pointers[1].pageX);
+        const y = 0.5 * (pointers[0].pageY + pointers[1].pageY);
+        panStart.set(x, y);
       }
-      return void 0;
-    }).catch((err) => {
-      console.warn(err);
-      return void 0;
-    });
-  }
-  static async getProfileFromMinetools(uuid) {
-    return Requests.genericRequest({
-      baseURL: "https://api.minetools.eu",
-      url: "/profile/" + uuid
-    }).then((res) => {
-      if (res.status === 200) {
-        return res.data;
+    }
+    function handleTouchStartDolly() {
+      const dx = pointers[0].pageX - pointers[1].pageX;
+      const dy = pointers[0].pageY - pointers[1].pageY;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      dollyStart.set(0, distance);
+    }
+    function handleTouchStartDollyPan() {
+      if (scope.enableZoom) handleTouchStartDolly();
+      if (scope.enablePan) handleTouchStartPan();
+    }
+    function handleTouchStartDollyRotate() {
+      if (scope.enableZoom) handleTouchStartDolly();
+      if (scope.enableRotate) handleTouchStartRotate();
+    }
+    function handleTouchMoveRotate(event) {
+      if (pointers.length == 1) {
+        rotateEnd.set(event.pageX, event.pageY);
+      } else {
+        const position = getSecondPointerPosition(event);
+        const x = 0.5 * (event.pageX + position.x);
+        const y = 0.5 * (event.pageY + position.y);
+        rotateEnd.set(x, y);
       }
-    });
-  }
-  static async getMineSkin(mineskinId) {
-    return Requests.genericRequest({
-      baseURL: "https://api.mineskin.org",
-      url: "/get/uuid/" + mineskinId
-    }).then((res) => {
-      if (res.status === 200) {
-        return res.data;
+      rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
+      const element = scope.domElement;
+      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
+      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
+      rotateStart.copy(rotateEnd);
+    }
+    function handleTouchMovePan(event) {
+      if (pointers.length === 1) {
+        panEnd.set(event.pageX, event.pageY);
+      } else {
+        const position = getSecondPointerPosition(event);
+        const x = 0.5 * (event.pageX + position.x);
+        const y = 0.5 * (event.pageY + position.y);
+        panEnd.set(x, y);
       }
-      return void 0;
-    }).catch((err) => {
-      console.warn(err);
-      return void 0;
-    });
-  }
-  static async getCapesDev(uuid, type = "all") {
-    return Requests.genericRequest({
-      baseURL: "https://api.capes.dev",
-      url: "/load/" + uuid + "/" + type
-    }).then((res) => {
-      if (res.status === 200) {
-        return res.data;
+      panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
+      pan(panDelta.x, panDelta.y);
+      panStart.copy(panEnd);
+    }
+    function handleTouchMoveDolly(event) {
+      const position = getSecondPointerPosition(event);
+      const dx = event.pageX - position.x;
+      const dy = event.pageY - position.y;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      dollyEnd.set(0, distance);
+      dollyDelta.set(0, Math.pow(dollyEnd.y / dollyStart.y, scope.zoomSpeed));
+      dollyOut(dollyDelta.y);
+      dollyStart.copy(dollyEnd);
+    }
+    function handleTouchMoveDollyPan(event) {
+      if (scope.enableZoom) handleTouchMoveDolly(event);
+      if (scope.enablePan) handleTouchMovePan(event);
+    }
+    function handleTouchMoveDollyRotate(event) {
+      if (scope.enableZoom) handleTouchMoveDolly(event);
+      if (scope.enableRotate) handleTouchMoveRotate(event);
+    }
+    function handleTouchEnd() {
+    }
+    function onPointerDown(event) {
+      if (scope.enabled === false) return;
+      if (pointers.length === 0) {
+        scope.domElement.setPointerCapture(event.pointerId);
+        scope.domElement.addEventListener("pointermove", onPointerMove);
+        scope.domElement.addEventListener("pointerup", onPointerUp);
       }
-      return void 0;
-    }).catch((err) => {
-      console.warn(err);
-      return void 0;
-    });
-  }
-  static getCrafatarSkinUrl(uuid) {
-    return "https://crafatar.com/skins/" + uuid;
-  }
-  static getCrafatarCapeUrl(uuid) {
-    return "https://crafatar.com/capes/" + uuid;
-  }
-  static getMcHeadsSkinUrl(uuid) {
-    return "https://mc-heads.net/skin/" + uuid;
-  }
-  static getMineSkinPlayerSkinUrl(uuid) {
-    return "https://mineskin.org/skin/player/" + uuid;
-  }
-  static getSkinProxySkinUrl(uuid) {
-    return "https://minecraft-skin-proxy.inventive.workers.dev/skin/" + uuid;
-  }
-  static getSkinProxyCapeUrl(uuid) {
-    return "https://minecraft-skin-proxy.inventive.workers.dev/cape/" + uuid;
-  }
-  //</editor-fold>
-};
-
-// src/three/OrbitControls.js
-var import_three20 = require("three");
-var _changeEvent = { type: "change" };
-var _startEvent = { type: "start" };
-var _endEvent = { type: "end" };
-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.');
-    if (domElement === document) console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.');
-    this.object = object;
-    this.domElement = domElement;
-    this.domElement.style.touchAction = "none";
-    this.enabled = true;
-    this.target = new import_three20.Vector3();
-    this.minDistance = 0;
-    this.maxDistance = Infinity;
-    this.minZoom = 0;
-    this.maxZoom = Infinity;
-    this.minPolarAngle = 0;
-    this.maxPolarAngle = Math.PI;
-    this.minAzimuthAngle = -Infinity;
-    this.maxAzimuthAngle = Infinity;
-    this.enableDamping = false;
-    this.dampingFactor = 0.05;
-    this.enableZoom = true;
-    this.zoomSpeed = 1;
-    this.enableRotate = true;
-    this.rotateSpeed = 1;
-    this.enablePan = true;
-    this.panSpeed = 1;
-    this.screenSpacePanning = true;
-    this.keyPanSpeed = 7;
-    this.autoRotate = false;
-    this.autoRotateSpeed = 2;
-    this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    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;
-    this._domElementKeyEvents = null;
-    this.getPolarAngle = function() {
-      return spherical.phi;
-    };
-    this.getAzimuthalAngle = function() {
-      return spherical.theta;
-    };
-    this.getDistance = function() {
-      return this.object.position.distanceTo(this.target);
-    };
-    this.saveState = function() {
-      scope.target0.copy(scope.target);
-      scope.position0.copy(scope.object.position);
-      scope.zoom0 = scope.object.zoom;
-    };
-    this.reset = function() {
-      scope.target.copy(scope.target0);
-      scope.object.position.copy(scope.position0);
-      scope.object.zoom = scope.zoom0;
-      scope.object.updateProjectionMatrix();
-      scope.dispatchEvent(_changeEvent);
-      scope.update();
-      state = STATE.NONE;
-    };
-    this.update = function() {
-      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_three20.Vector3();
-      const lastQuaternion = new import_three20.Quaternion();
-      const twoPI = 2 * Math.PI;
-      return function update() {
-        const position = scope.object.position;
-        offset.copy(position).sub(scope.target);
-        offset.applyQuaternion(quat);
-        spherical.setFromVector3(offset);
-        if (scope.autoRotate && state === STATE.NONE) {
-          rotateLeft(getAutoRotationAngle());
-        }
-        if (scope.enableDamping) {
-          spherical.theta += sphericalDelta.theta * scope.dampingFactor;
-          spherical.phi += sphericalDelta.phi * scope.dampingFactor;
-        } else {
-          spherical.theta += sphericalDelta.theta;
-          spherical.phi += sphericalDelta.phi;
-        }
-        let min = scope.minAzimuthAngle;
-        let max = scope.maxAzimuthAngle;
-        if (isFinite(min) && isFinite(max)) {
-          if (min < -Math.PI) min += twoPI;
-          else if (min > Math.PI) min -= twoPI;
-          if (max < -Math.PI) max += twoPI;
-          else if (max > Math.PI) max -= twoPI;
-          if (min <= max) {
-            spherical.theta = Math.max(min, Math.min(max, spherical.theta));
+      addPointer(event);
+      if (event.pointerType === "touch") {
+        onTouchStart(event);
+      } else {
+        onMouseDown(event);
+      }
+    }
+    function onPointerMove(event) {
+      if (scope.enabled === false) return;
+      if (event.pointerType === "touch") {
+        onTouchMove(event);
+      } else {
+        onMouseMove(event);
+      }
+    }
+    function onPointerUp(event) {
+      if (scope.enabled === false) return;
+      if (event.pointerType === "touch") {
+        onTouchEnd();
+      } else {
+        onMouseUp(event);
+      }
+      removePointer(event);
+      if (pointers.length === 0) {
+        scope.domElement.releasePointerCapture(event.pointerId);
+        scope.domElement.removeEventListener("pointermove", onPointerMove);
+        scope.domElement.removeEventListener("pointerup", onPointerUp);
+      }
+    }
+    function onPointerCancel(event) {
+      removePointer(event);
+    }
+    function onMouseDown(event) {
+      let mouseAction;
+      switch (event.button) {
+        case 0:
+          mouseAction = scope.mouseButtons.LEFT;
+          break;
+        case 1:
+          mouseAction = scope.mouseButtons.MIDDLE;
+          break;
+        case 2:
+          mouseAction = scope.mouseButtons.RIGHT;
+          break;
+        default:
+          mouseAction = -1;
+      }
+      switch (mouseAction) {
+        case import_three18.MOUSE.DOLLY:
+          if (scope.enableZoom === false) return;
+          handleMouseDownDolly(event);
+          state = STATE.DOLLY;
+          break;
+        case import_three18.MOUSE.ROTATE:
+          if (event.ctrlKey || event.metaKey || event.shiftKey) {
+            if (scope.enablePan === false) return;
+            handleMouseDownPan(event);
+            state = STATE.PAN;
+          } else {
+            if (scope.enableRotate === false) return;
+            handleMouseDownRotate(event);
+            state = STATE.ROTATE;
+          }
+          break;
+        case import_three18.MOUSE.PAN:
+          if (event.ctrlKey || event.metaKey || event.shiftKey) {
+            if (scope.enableRotate === false) return;
+            handleMouseDownRotate(event);
+            state = STATE.ROTATE;
           } else {
-            spherical.theta = spherical.theta > (min + max) / 2 ? Math.max(min, spherical.theta) : Math.min(max, spherical.theta);
+            if (scope.enablePan === false) return;
+            handleMouseDownPan(event);
+            state = STATE.PAN;
           }
-        }
-        spherical.phi = Math.max(scope.minPolarAngle, Math.min(scope.maxPolarAngle, spherical.phi));
-        spherical.makeSafe();
-        spherical.radius *= scale;
-        spherical.radius = Math.max(scope.minDistance, Math.min(scope.maxDistance, spherical.radius));
-        if (scope.enableDamping === true) {
-          scope.target.addScaledVector(panOffset, scope.dampingFactor);
-        } else {
-          scope.target.add(panOffset);
-        }
-        offset.setFromSpherical(spherical);
-        offset.applyQuaternion(quatInverse);
-        position.copy(scope.target).add(offset);
-        scope.object.lookAt(scope.target);
-        if (scope.enableDamping === true) {
-          sphericalDelta.theta *= 1 - scope.dampingFactor;
-          sphericalDelta.phi *= 1 - scope.dampingFactor;
-          panOffset.multiplyScalar(1 - scope.dampingFactor);
-        } else {
-          sphericalDelta.set(0, 0, 0);
-          panOffset.set(0, 0, 0);
-        }
-        scale = 1;
-        if (zoomChanged || lastPosition.distanceToSquared(scope.object.position) > EPS || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS) {
-          scope.dispatchEvent(_changeEvent);
-          lastPosition.copy(scope.object.position);
-          lastQuaternion.copy(scope.object.quaternion);
-          zoomChanged = false;
-          return true;
-        }
-        return false;
-      };
-    }();
-    this.dispose = function() {
-      scope.domElement.removeEventListener("contextmenu", onContextMenu);
-      scope.domElement.removeEventListener("pointerdown", onPointerDown);
-      scope.domElement.removeEventListener("pointercancel", onPointerCancel);
-      scope.domElement.removeEventListener("wheel", onMouseWheel);
-      scope.domElement.removeEventListener("pointermove", onPointerMove);
-      scope.domElement.removeEventListener("pointerup", onPointerUp);
-      if (scope._domElementKeyEvents !== null) {
-        scope._domElementKeyEvents.removeEventListener("keydown", onKeyDown);
+          break;
+        default:
+          state = STATE.NONE;
+      }
+      if (state !== STATE.NONE) {
+        scope.dispatchEvent(_startEvent);
       }
-    };
-    const scope = this;
-    const STATE = {
-      NONE: -1,
-      ROTATE: 0,
-      DOLLY: 1,
-      PAN: 2,
-      TOUCH_ROTATE: 3,
-      TOUCH_PAN: 4,
-      TOUCH_DOLLY_PAN: 5,
-      TOUCH_DOLLY_ROTATE: 6
-    };
-    let state = STATE.NONE;
-    const EPS = 1e-6;
-    const spherical = new import_three20.Spherical();
-    const sphericalDelta = new import_three20.Spherical();
-    let scale = 1;
-    const panOffset = new import_three20.Vector3();
-    let zoomChanged = false;
-    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() {
-      return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
     }
-    function getZoomScale() {
-      return Math.pow(0.95, scope.zoomSpeed);
+    function onMouseMove(event) {
+      if (scope.enabled === false) return;
+      switch (state) {
+        case STATE.ROTATE:
+          if (scope.enableRotate === false) return;
+          handleMouseMoveRotate(event);
+          break;
+        case STATE.DOLLY:
+          if (scope.enableZoom === false) return;
+          handleMouseMoveDolly(event);
+          break;
+        case STATE.PAN:
+          if (scope.enablePan === false) return;
+          handleMouseMovePan(event);
+          break;
+      }
     }
-    function rotateLeft(angle) {
-      sphericalDelta.theta -= angle;
+    function onMouseUp(event) {
+      handleMouseUp(event);
+      scope.dispatchEvent(_endEvent);
+      state = STATE.NONE;
     }
-    function rotateUp(angle) {
-      sphericalDelta.phi -= angle;
+    function onMouseWheel(event) {
+      if (scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE) return;
+      event.preventDefault();
+      scope.dispatchEvent(_startEvent);
+      handleMouseWheel(event);
+      scope.dispatchEvent(_endEvent);
     }
-    const panLeft = function() {
-      const v = new import_three20.Vector3();
-      return function panLeft2(distance, objectMatrix) {
-        v.setFromMatrixColumn(objectMatrix, 0);
-        v.multiplyScalar(-distance);
-        panOffset.add(v);
-      };
-    }();
-    const panUp = function() {
-      const v = new import_three20.Vector3();
-      return function panUp2(distance, objectMatrix) {
-        if (scope.screenSpacePanning === true) {
-          v.setFromMatrixColumn(objectMatrix, 1);
-        } else {
-          v.setFromMatrixColumn(objectMatrix, 0);
-          v.crossVectors(scope.object.up, v);
-        }
-        v.multiplyScalar(distance);
-        panOffset.add(v);
-      };
-    }();
-    const pan = function() {
-      const offset = new import_three20.Vector3();
-      return function pan2(deltaX, deltaY) {
-        const element = scope.domElement;
-        if (scope.object.isPerspectiveCamera) {
-          const position = scope.object.position;
-          offset.copy(position).sub(scope.target);
-          let targetDistance = offset.length();
-          targetDistance *= Math.tan(scope.object.fov / 2 * Math.PI / 180);
-          panLeft(2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix);
-          panUp(2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix);
-        } else if (scope.object.isOrthographicCamera) {
-          panLeft(deltaX * (scope.object.right - scope.object.left) / scope.object.zoom / element.clientWidth, scope.object.matrix);
-          panUp(deltaY * (scope.object.top - scope.object.bottom) / scope.object.zoom / element.clientHeight, scope.object.matrix);
-        } else {
-          console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.");
-          scope.enablePan = false;
+    function onKeyDown(event) {
+      if (scope.enabled === false || scope.enablePan === false) return;
+      handleKeyDown(event);
+    }
+    function onTouchStart(event) {
+      trackPointer(event);
+      switch (pointers.length) {
+        case 1:
+          switch (scope.touches.ONE) {
+            case import_three18.TOUCH.ROTATE:
+              if (scope.enableRotate === false) return;
+              handleTouchStartRotate();
+              state = STATE.TOUCH_ROTATE;
+              break;
+            case import_three18.TOUCH.PAN:
+              if (scope.enablePan === false) return;
+              handleTouchStartPan();
+              state = STATE.TOUCH_PAN;
+              break;
+            default:
+              state = STATE.NONE;
+          }
+          break;
+        case 2:
+          switch (scope.touches.TWO) {
+            case import_three18.TOUCH.DOLLY_PAN:
+              if (scope.enableZoom === false && scope.enablePan === false) return;
+              handleTouchStartDollyPan();
+              state = STATE.TOUCH_DOLLY_PAN;
+              break;
+            case import_three18.TOUCH.DOLLY_ROTATE:
+              if (scope.enableZoom === false && scope.enableRotate === false) return;
+              handleTouchStartDollyRotate();
+              state = STATE.TOUCH_DOLLY_ROTATE;
+              break;
+            default:
+              state = STATE.NONE;
+          }
+          break;
+        default:
+          state = STATE.NONE;
+      }
+      if (state !== STATE.NONE) {
+        scope.dispatchEvent(_startEvent);
+      }
+    }
+    function onTouchMove(event) {
+      trackPointer(event);
+      switch (state) {
+        case STATE.TOUCH_ROTATE:
+          if (scope.enableRotate === false) return;
+          handleTouchMoveRotate(event);
+          scope.update();
+          break;
+        case STATE.TOUCH_PAN:
+          if (scope.enablePan === false) return;
+          handleTouchMovePan(event);
+          scope.update();
+          break;
+        case STATE.TOUCH_DOLLY_PAN:
+          if (scope.enableZoom === false && scope.enablePan === false) return;
+          handleTouchMoveDollyPan(event);
+          scope.update();
+          break;
+        case STATE.TOUCH_DOLLY_ROTATE:
+          if (scope.enableZoom === false && scope.enableRotate === false) return;
+          handleTouchMoveDollyRotate(event);
+          scope.update();
+          break;
+        default:
+          state = STATE.NONE;
+      }
+    }
+    function onTouchEnd(event) {
+      handleTouchEnd(event);
+      scope.dispatchEvent(_endEvent);
+      state = STATE.NONE;
+    }
+    function onContextMenu(event) {
+      if (scope.enabled === false) return;
+      event.preventDefault();
+    }
+    function addPointer(event) {
+      pointers.push(event);
+    }
+    function removePointer(event) {
+      delete pointerPositions[event.pointerId];
+      for (let i = 0; i < pointers.length; i++) {
+        if (pointers[i].pointerId == event.pointerId) {
+          pointers.splice(i, 1);
+          return;
         }
-      };
-    }();
-    function dollyOut(dollyScale) {
-      if (scope.object.isPerspectiveCamera) {
-        scale /= dollyScale;
-      } else if (scope.object.isOrthographicCamera) {
-        scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom * dollyScale));
-        scope.object.updateProjectionMatrix();
-        zoomChanged = true;
-      } else {
-        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
-        scope.enableZoom = false;
       }
     }
-    function dollyIn(dollyScale) {
-      if (scope.object.isPerspectiveCamera) {
-        scale *= dollyScale;
-      } else if (scope.object.isOrthographicCamera) {
-        scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / dollyScale));
-        scope.object.updateProjectionMatrix();
-        zoomChanged = true;
-      } else {
-        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
-        scope.enableZoom = false;
+    function trackPointer(event) {
+      let position = pointerPositions[event.pointerId];
+      if (position === void 0) {
+        position = new import_three18.Vector2();
+        pointerPositions[event.pointerId] = position;
       }
+      position.set(event.pageX, event.pageY);
     }
-    function handleMouseDownRotate(event) {
-      rotateStart.set(event.clientX, event.clientY);
-    }
-    function handleMouseDownDolly(event) {
-      dollyStart.set(event.clientX, event.clientY);
+    function getSecondPointerPosition(event) {
+      const pointer = event.pointerId === pointers[0].pointerId ? pointers[1] : pointers[0];
+      return pointerPositions[pointer.pointerId];
     }
-    function handleMouseDownPan(event) {
-      panStart.set(event.clientX, event.clientY);
+    scope.domElement.addEventListener("contextmenu", onContextMenu);
+    scope.domElement.addEventListener("pointerdown", onPointerDown);
+    scope.domElement.addEventListener("pointercancel", onPointerCancel);
+    scope.domElement.addEventListener("wheel", onMouseWheel, { passive: false });
+    this.update();
+  }
+};
+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;
+  }
+};
+
+// src/renderer/Renderer.ts
+var _Renderer = class _Renderer {
+  constructor(options) {
+    this._dirty = true;
+    this._resizeListener = void 0;
+    this._disposed = false;
+    this._debugHelpers = [];
+    this._eventDispatchers = /* @__PURE__ */ new Map();
+    this._changeListener = () => {
+      this._dirty = true;
+    };
+    this.options = (0, import_ts_deepmerge9.default)({}, _Renderer.DEFAULT_OPTIONS, options ?? {});
+    this._animationLoop = this.animate.bind(this);
+    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();
+    this._composer = this.createComposer();
+    if (this.options.render.stats) {
+      this._stats = new import_stats.default();
+      document.body.appendChild(this._stats.dom);
     }
-    function handleMouseMoveRotate(event) {
-      rotateEnd.set(event.clientX, event.clientY);
-      rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
-      const element = scope.domElement;
-      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
-      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
-      rotateStart.copy(rotateEnd);
-      scope.update();
+    this.init();
+    this._controls = this.createControls();
+  }
+  //<editor-fold desc="INIT">
+  createScene() {
+    return new MineRenderScene();
+  }
+  createCamera() {
+    switch (this.options.camera.type) {
+      case "perspective":
+      default:
+        return new import_three19.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(
+          this.options.camera.orthographic.left ?? this.viewWidth / -2,
+          this.options.camera.orthographic.right ?? this.viewWidth / 2,
+          this.options.camera.orthographic.top ?? this.viewHeight / 2,
+          this.options.camera.orthographic.bottom ?? this.viewHeight / -2,
+          this.options.camera.near,
+          this.options.camera.far
+        );
     }
-    function handleMouseMoveDolly(event) {
-      dollyEnd.set(event.clientX, event.clientY);
-      dollyDelta.subVectors(dollyEnd, dollyStart);
-      if (dollyDelta.y > 0) {
-        dollyOut(getZoomScale());
-      } else if (dollyDelta.y < 0) {
-        dollyIn(getZoomScale());
-      }
-      dollyStart.copy(dollyEnd);
-      scope.update();
+  }
+  createRenderer() {
+    const renderer = new import_three19.WebGLRenderer({
+      antialias: this.options.render.antialias,
+      alpha: true,
+      powerPreference: "high-performance",
+      depth: true
+    });
+    renderer.setClearColor(0, 0);
+    renderer.shadowMap.enabled = true;
+    renderer.shadowMap.type = import_three19.PCFSoftShadowMap;
+    renderer.outputColorSpace = import_three19.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);
+    composer.setSize(this.viewWidth, this.viewHeight);
+    composer.addPass(new import_postprocessing.RenderPass(this.scene, this.camera));
+    return composer;
+  }
+  createControls() {
+    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);
+    const target = this.options.camera.lookingAt;
+    if (isVector3(target)) {
+      controls.target.copy(target);
+    } else if (isTripleArray(target)) {
+      controls.target.set(target[0], target[1], target[2]);
+    }
+    controls.update();
+    controls.saveState();
+    this.registerEventDispatcher(controls);
+    return controls;
+  }
+  //</editor-fold>
+  init() {
+    if (this._disposed) return;
+    if (typeof window["__THREE_DEVTOOLS__"] !== "undefined") {
+      window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
-    function handleMouseMovePan(event) {
-      panEnd.set(event.clientX, event.clientY);
-      panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
-      pan(panDelta.x, panDelta.y);
-      panStart.copy(panEnd);
-      scope.update();
+    if (this.options.debug.grid) {
+      const gridHelper = new import_three19.GridHelper(128, 16);
+      this._debugHelpers.push(gridHelper);
+      this.scene.add(gridHelper);
+      const gridHelper2 = new import_three19.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);
+      this._debugHelpers.push(gridHelper3);
+      gridHelper3.rotation.z = 90 * (Math.PI / 180);
+      this.scene.add(gridHelper3);
     }
-    function handleMouseUp() {
+    if (this.options.debug.axes) {
+      const axesHelper = new import_three19.AxesHelper(64);
+      this._debugHelpers.push(axesHelper);
+      this.scene.add(axesHelper);
     }
-    function handleMouseWheel(event) {
-      if (event.deltaY < 0) {
-        dollyIn(getZoomScale());
-      } else if (event.deltaY > 0) {
-        dollyOut(getZoomScale());
+    if (this.options.camera.position) {
+      if (isVector3(this.options.camera.position)) {
+        this.camera.position.set(this.options.camera.position.x, this.options.camera.position.y, this.options.camera.position.z);
+      } else if (isTripleArray(this.options.camera.position)) {
+        this.camera.position.set(this.options.camera.position[0], this.options.camera.position[1], this.options.camera.position[2]);
       }
-      scope.update();
     }
-    function handleKeyDown(event) {
-      let needsUpdate = false;
-      switch (event.code) {
-        case scope.keys.UP:
-          pan(0, scope.keyPanSpeed);
-          needsUpdate = true;
-          break;
-        case scope.keys.BOTTOM:
-          pan(0, -scope.keyPanSpeed);
-          needsUpdate = true;
-          break;
-        case scope.keys.LEFT:
-          pan(scope.keyPanSpeed, 0);
-          needsUpdate = true;
-          break;
-        case scope.keys.RIGHT:
-          pan(-scope.keyPanSpeed, 0);
-          needsUpdate = true;
-          break;
-      }
-      if (needsUpdate) {
-        event.preventDefault();
-        scope.update();
+    if (this.options.camera.lookingAt) {
+      if (isVector3(this.options.camera.lookingAt)) {
+        this.camera.lookAt(this.options.camera.lookingAt);
+      } else if (isTripleArray(this.options.camera.lookingAt)) {
+        this.camera.lookAt(this.options.camera.lookingAt[0], this.options.camera.lookingAt[1], this.options.camera.lookingAt[2]);
       }
     }
-    function handleTouchStartRotate() {
-      if (pointers.length === 1) {
-        rotateStart.set(pointers[0].pageX, pointers[0].pageY);
-      } else {
-        const x = 0.5 * (pointers[0].pageX + pointers[1].pageX);
-        const y = 0.5 * (pointers[0].pageY + pointers[1].pageY);
-        rotateStart.set(x, y);
-      }
+    if (this.options.render.autoResize && !this._resizeListener) {
+      this._resizeListener = () => {
+        this.resize(this.viewWidth, this.viewHeight);
+      };
+      window.addEventListener("resize", this._resizeListener);
+    }
+  }
+  get element() {
+    return this._element;
+  }
+  appendTo(element) {
+    if (this._disposed) return;
+    this._element = element;
+    this._element.appendChild(this.renderer.domElement);
+    if (this.viewWidth == 0) {
+      console.warn("0 element width");
+    }
+    if (this.viewHeight == 0) {
+      console.warn("0 element height");
+    }
+    this.resize(this.viewWidth, this.viewHeight);
+  }
+  /**
+   * Redraws when the dispatcher emits the selected event. Registering the same pair twice has no effect.
+   * The renderer removes its listener on disposal; the caller retains ownership of the dispatcher.
+   */
+  registerEventDispatcher(dispatcher, changeEvent2 = "change") {
+    if (this._disposed) return;
+    let events = this._eventDispatchers.get(dispatcher);
+    if (!events) {
+      events = /* @__PURE__ */ new Set();
+      this._eventDispatchers.set(dispatcher, events);
+    }
+    if (events.has(changeEvent2)) return;
+    events.add(changeEvent2);
+    dispatcher.addEventListener(changeEvent2, this._changeListener);
+  }
+  resize(width, height) {
+    if (this._disposed) return;
+    if (isPerspectiveCamera(this.camera)) {
+      this.camera.aspect = width / height;
+      this.camera.updateProjectionMatrix();
+    } else if (isOrthographicCamera(this.camera)) {
+      this.camera.left = width / -2;
+      this.camera.right = width / 2;
+      this.camera.top = height / 2;
+      this.camera.bottom = height / -2;
+      this.camera.updateProjectionMatrix();
+    }
+    this.renderer.setSize(width, height);
+    this.composer?.setSize(width, height);
+    this._dirty = true;
+  }
+  //<editor-fold desc="RENDER">
+  get dirty() {
+    return this._dirty || this.scene.dirty;
+  }
+  set dirty(dirty) {
+    this._dirty = dirty;
+    this.scene.dirty = dirty;
+  }
+  start() {
+    if (this._disposed) return;
+    this.stop();
+    this.renderer.setAnimationLoop(this._animationLoop);
+  }
+  stop() {
+    if (this._disposed) return;
+    this.renderer.setAnimationLoop(null);
+    this._nextFrameTime = void 0;
+  }
+  /**
+   * Stops rendering and releases owned resources. Repeated calls have no effect, and a disposed
+   * renderer cannot be restarted. Scene objects are detached; shared assets and caller-owned
+   * controls must be managed by their owners.
+   */
+  dispose() {
+    if (this._disposed) return;
+    this.stop();
+    this._disposed = true;
+    if (this._resizeListener) {
+      window.removeEventListener("resize", this._resizeListener);
+      this._resizeListener = void 0;
     }
-    function handleTouchStartPan() {
-      if (pointers.length === 1) {
-        panStart.set(pointers[0].pageX, pointers[0].pageY);
-      } else {
-        const x = 0.5 * (pointers[0].pageX + pointers[1].pageX);
-        const y = 0.5 * (pointers[0].pageY + pointers[1].pageY);
-        panStart.set(x, y);
+    for (const [dispatcher, events] of this._eventDispatchers) {
+      for (const event of events) {
+        dispatcher.removeEventListener(event, this._changeListener);
       }
     }
-    function handleTouchStartDolly() {
-      const dx = pointers[0].pageX - pointers[1].pageX;
-      const dy = pointers[0].pageY - pointers[1].pageY;
-      const distance = Math.sqrt(dx * dx + dy * dy);
-      dollyStart.set(0, distance);
-    }
-    function handleTouchStartDollyPan() {
-      if (scope.enableZoom) handleTouchStartDolly();
-      if (scope.enablePan) handleTouchStartPan();
-    }
-    function handleTouchStartDollyRotate() {
-      if (scope.enableZoom) handleTouchStartDolly();
-      if (scope.enableRotate) handleTouchStartRotate();
-    }
-    function handleTouchMoveRotate(event) {
-      if (pointers.length == 1) {
-        rotateEnd.set(event.pageX, event.pageY);
-      } else {
-        const position = getSecondPointerPosition(event);
-        const x = 0.5 * (event.pageX + position.x);
-        const y = 0.5 * (event.pageY + position.y);
-        rotateEnd.set(x, y);
-      }
-      rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
-      const element = scope.domElement;
-      rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
-      rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
-      rotateStart.copy(rotateEnd);
+    this._eventDispatchers.clear();
+    this._stats?.dom.remove();
+    this._stats = void 0;
+    this.renderer.domElement.remove();
+    this._element = void 0;
+    if (this._controls) {
+      const controls = this._controls;
+      this._controls = void 0;
+      controls.enabled = false;
+      controls.dispose();
     }
-    function handleTouchMovePan(event) {
-      if (pointers.length === 1) {
-        panEnd.set(event.pageX, event.pageY);
-      } else {
-        const position = getSecondPointerPosition(event);
-        const x = 0.5 * (event.pageX + position.x);
-        const y = 0.5 * (event.pageY + position.y);
-        panEnd.set(x, y);
+    this.scene.clear();
+    for (const helper of this._debugHelpers) {
+      helper.geometry.dispose();
+      const materials = Array.isArray(helper.material) ? helper.material : [helper.material];
+      for (const material of materials) {
+        material.dispose();
       }
-      panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
-      pan(panDelta.x, panDelta.y);
-      panStart.copy(panEnd);
-    }
-    function handleTouchMoveDolly(event) {
-      const position = getSecondPointerPosition(event);
-      const dx = event.pageX - position.x;
-      const dy = event.pageY - position.y;
-      const distance = Math.sqrt(dx * dx + dy * dy);
-      dollyEnd.set(0, distance);
-      dollyDelta.set(0, Math.pow(dollyEnd.y / dollyStart.y, scope.zoomSpeed));
-      dollyOut(dollyDelta.y);
-      dollyStart.copy(dollyEnd);
     }
-    function handleTouchMoveDollyPan(event) {
-      if (scope.enableZoom) handleTouchMoveDolly(event);
-      if (scope.enablePan) handleTouchMovePan(event);
-    }
-    function handleTouchMoveDollyRotate(event) {
-      if (scope.enableZoom) handleTouchMoveDolly(event);
-      if (scope.enableRotate) handleTouchMoveRotate(event);
+    this._debugHelpers.length = 0;
+    this.composer?.dispose();
+    this.renderer.dispose();
+    this.renderer.forceContextLoss();
+  }
+  animate(t = performance.now()) {
+    if (this._disposed) return;
+    if (this._controls?.enabled) {
+      this._controls.update();
     }
-    function handleTouchEnd() {
+    if (this._disposed) return;
+    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;
     }
-    function onPointerDown(event) {
-      if (scope.enabled === false) return;
-      if (pointers.length === 0) {
-        scope.domElement.setPointerCapture(event.pointerId);
-        scope.domElement.addEventListener("pointermove", onPointerMove);
-        scope.domElement.addEventListener("pointerup", onPointerUp);
-      }
-      addPointer(event);
-      if (event.pointerType === "touch") {
-        onTouchStart(event);
-      } else {
-        onMouseDown(event);
-      }
+    if (this._stats) {
+      this._stats.begin();
     }
-    function onPointerMove(event) {
-      if (scope.enabled === false) return;
-      if (event.pointerType === "touch") {
-        onTouchMove(event);
-      } else {
-        onMouseMove(event);
-      }
+    if (this.options.composer.enabled && this.composer) {
+      this.composer.render();
+    } else {
+      this.renderer.render(this.scene, this.camera);
     }
-    function onPointerUp(event) {
-      if (scope.enabled === false) return;
-      if (event.pointerType === "touch") {
-        onTouchEnd();
-      } else {
-        onMouseUp(event);
-      }
-      removePointer(event);
-      if (pointers.length === 0) {
-        scope.domElement.releasePointerCapture(event.pointerId);
-        scope.domElement.removeEventListener("pointermove", onPointerMove);
-        scope.domElement.removeEventListener("pointerup", onPointerUp);
-      }
+    this.dirty = false;
+    if (this._stats) {
+      this._stats.end();
     }
-    function onPointerCancel(event) {
-      removePointer(event);
+  }
+  //</editor-fold>
+  toImage() {
+    return this.renderer.domElement.toDataURL();
+  }
+  ///
+  get attachedToBody() {
+    return this.element === document.body;
+  }
+  get viewWidth() {
+    return this.attachedToBody ? window.innerWidth : this.element?.offsetWidth || 0;
+  }
+  get viewHeight() {
+    return this.attachedToBody ? window.innerHeight : this.element?.offsetHeight || 0;
+  }
+  get scene() {
+    return this._scene;
+  }
+  get camera() {
+    return this._camera;
+  }
+  get renderer() {
+    return this._renderer;
+  }
+  get composer() {
+    return this._composer;
+  }
+  /** Renderer-owned controls, or undefined when disabled at construction or after disposal. */
+  get controls() {
+    return this._controls;
+  }
+  ///
+};
+_Renderer.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_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 {
+  //<editor-fold desc="Skins">
+  static async fromUuidOrUsername(uuidOrUsername) {
+    if (uuidOrUsername.length === 32 || uuidOrUsername.length === 36) {
+      return this.fromUuid(uuidOrUsername);
     }
-    function onMouseDown(event) {
-      let mouseAction;
-      switch (event.button) {
-        case 0:
-          mouseAction = scope.mouseButtons.LEFT;
-          break;
-        case 1:
-          mouseAction = scope.mouseButtons.MIDDLE;
-          break;
-        case 2:
-          mouseAction = scope.mouseButtons.RIGHT;
-          break;
-        default:
-          mouseAction = -1;
-      }
-      switch (mouseAction) {
-        case import_three20.MOUSE.DOLLY:
-          if (scope.enableZoom === false) return;
-          handleMouseDownDolly(event);
-          state = STATE.DOLLY;
-          break;
-        case import_three20.MOUSE.ROTATE:
-          if (event.ctrlKey || event.metaKey || event.shiftKey) {
-            if (scope.enablePan === false) return;
-            handleMouseDownPan(event);
-            state = STATE.PAN;
-          } else {
-            if (scope.enableRotate === false) return;
-            handleMouseDownRotate(event);
-            state = STATE.ROTATE;
-          }
-          break;
-        case import_three20.MOUSE.PAN:
-          if (event.ctrlKey || event.metaKey || event.shiftKey) {
-            if (scope.enableRotate === false) return;
-            handleMouseDownRotate(event);
-            state = STATE.ROTATE;
-          } else {
-            if (scope.enablePan === false) return;
-            handleMouseDownPan(event);
-            state = STATE.PAN;
-          }
-          break;
-        default:
-          state = STATE.NONE;
+    return this.fromUsername(uuidOrUsername);
+  }
+  static async fromUuid(uuid) {
+    return this.getMcProxySkinUrl(uuid);
+  }
+  static async fromUsername(username) {
+    return this.usernameToUuid(username).then((uuid) => {
+      if (uuid) {
+        return this.fromUuid(uuid);
       }
-      if (state !== STATE.NONE) {
-        scope.dispatchEvent(_startEvent);
+      return void 0;
+    });
+  }
+  static async fromMineSkin(mineskinId) {
+    return this.getMineSkin(mineskinId).then((mineskin) => {
+      if (mineskin) {
+        return mineskin["data"]["texture"]["value"]["urls"]["skins"];
       }
+      return void 0;
+    });
+  }
+  //</editor-fold>
+  //<editor-fold desc="Capes">
+  static async capeFromUuidOrUsername(uuidOrUsername) {
+    if (uuidOrUsername.length === 32 || uuidOrUsername.length === 36) {
+      return this.capeFromUuid(uuidOrUsername);
     }
-    function onMouseMove(event) {
-      if (scope.enabled === false) return;
-      switch (state) {
-        case STATE.ROTATE:
-          if (scope.enableRotate === false) return;
-          handleMouseMoveRotate(event);
-          break;
-        case STATE.DOLLY:
-          if (scope.enableZoom === false) return;
-          handleMouseMoveDolly(event);
-          break;
-        case STATE.PAN:
-          if (scope.enablePan === false) return;
-          handleMouseMovePan(event);
-          break;
+    return this.capeFromUsername(uuidOrUsername);
+  }
+  static async capeFromUuid(uuid) {
+    return this.getMcProxyCapeUrl(uuid);
+  }
+  static async capeFromUsername(username) {
+    return this.usernameToUuid(username).then((uuid) => {
+      if (uuid) {
+        return this.capeFromUuid(uuid);
       }
-    }
-    function onMouseUp(event) {
-      handleMouseUp(event);
-      scope.dispatchEvent(_endEvent);
-      state = STATE.NONE;
-    }
-    function onMouseWheel(event) {
-      if (scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE) return;
-      event.preventDefault();
-      scope.dispatchEvent(_startEvent);
-      handleMouseWheel(event);
-      scope.dispatchEvent(_endEvent);
-    }
-    function onKeyDown(event) {
-      if (scope.enabled === false || scope.enablePan === false) return;
-      handleKeyDown(event);
-    }
-    function onTouchStart(event) {
-      trackPointer(event);
-      switch (pointers.length) {
-        case 1:
-          switch (scope.touches.ONE) {
-            case import_three20.TOUCH.ROTATE:
-              if (scope.enableRotate === false) return;
-              handleTouchStartRotate();
-              state = STATE.TOUCH_ROTATE;
-              break;
-            case import_three20.TOUCH.PAN:
-              if (scope.enablePan === false) return;
-              handleTouchStartPan();
-              state = STATE.TOUCH_PAN;
-              break;
-            default:
-              state = STATE.NONE;
-          }
-          break;
-        case 2:
-          switch (scope.touches.TWO) {
-            case import_three20.TOUCH.DOLLY_PAN:
-              if (scope.enableZoom === false && scope.enablePan === false) return;
-              handleTouchStartDollyPan();
-              state = STATE.TOUCH_DOLLY_PAN;
-              break;
-            case import_three20.TOUCH.DOLLY_ROTATE:
-              if (scope.enableZoom === false && scope.enableRotate === false) return;
-              handleTouchStartDollyRotate();
-              state = STATE.TOUCH_DOLLY_ROTATE;
-              break;
-            default:
-              state = STATE.NONE;
-          }
-          break;
-        default:
-          state = STATE.NONE;
+      return void 0;
+    });
+  }
+  static async capeFromCapesDev(uuid, capeType = "minecraft") {
+    return this.getCapesDev(uuid, capeType).then((cape) => {
+      if (cape) {
+        return cape?.stillImageUrl;
       }
-      if (state !== STATE.NONE) {
-        scope.dispatchEvent(_startEvent);
+      return void 0;
+    });
+  }
+  //</editor-fold>
+  //<editor-fold desc="Helpers">
+  static async usernameToUuid(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"];
       }
-    }
-    function onTouchMove(event) {
-      trackPointer(event);
-      switch (state) {
-        case STATE.TOUCH_ROTATE:
-          if (scope.enableRotate === false) return;
-          handleTouchMoveRotate(event);
-          scope.update();
-          break;
-        case STATE.TOUCH_PAN:
-          if (scope.enablePan === false) return;
-          handleTouchMovePan(event);
-          scope.update();
-          break;
-        case STATE.TOUCH_DOLLY_PAN:
-          if (scope.enableZoom === false && scope.enablePan === false) return;
-          handleTouchMoveDollyPan(event);
-          scope.update();
-          break;
-        case STATE.TOUCH_DOLLY_ROTATE:
-          if (scope.enableZoom === false && scope.enableRotate === false) return;
-          handleTouchMoveDollyRotate(event);
-          scope.update();
-          break;
-        default:
-          state = STATE.NONE;
+      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",
+      url: "/uuid/" + username
+    }).then((res) => {
+      if (res.status === 200) {
+        return res.data["id"];
       }
-    }
-    function onTouchEnd(event) {
-      handleTouchEnd(event);
-      scope.dispatchEvent(_endEvent);
-      state = STATE.NONE;
-    }
-    function onContextMenu(event) {
-      if (scope.enabled === false) return;
-      event.preventDefault();
-    }
-    function addPointer(event) {
-      pointers.push(event);
-    }
-    function removePointer(event) {
-      delete pointerPositions[event.pointerId];
-      for (let i = 0; i < pointers.length; i++) {
-        if (pointers[i].pointerId == event.pointerId) {
-          pointers.splice(i, 1);
-          return;
-        }
+      return void 0;
+    }).catch((err) => {
+      console.warn(err);
+      return void 0;
+    });
+  }
+  static async usernameToUuidMineTools(username) {
+    return Requests.genericRequest({
+      baseURL: "https://api.minetools.eu",
+      url: "/uuid/" + username
+    }).then((res) => {
+      if (res.status === 200) {
+        return res.data["id"];
       }
-    }
-    function trackPointer(event) {
-      let position = pointerPositions[event.pointerId];
-      if (position === void 0) {
-        position = new import_three20.Vector2();
-        pointerPositions[event.pointerId] = position;
+      return void 0;
+    }).catch((err) => {
+      console.warn(err);
+      return void 0;
+    });
+  }
+  static async getProfileFromMinetools(uuid) {
+    return Requests.genericRequest({
+      baseURL: "https://api.minetools.eu",
+      url: "/profile/" + uuid
+    }).then((res) => {
+      if (res.status === 200) {
+        return res.data;
       }
-      position.set(event.pageX, event.pageY);
-    }
-    function getSecondPointerPosition(event) {
-      const pointer = event.pointerId === pointers[0].pointerId ? pointers[1] : pointers[0];
-      return pointerPositions[pointer.pointerId];
-    }
-    scope.domElement.addEventListener("contextmenu", onContextMenu);
-    scope.domElement.addEventListener("pointerdown", onPointerDown);
-    scope.domElement.addEventListener("pointercancel", onPointerCancel);
-    scope.domElement.addEventListener("wheel", onMouseWheel, { passive: false });
-    this.update();
+    });
   }
-};
-var MapControls = class extends OrbitControls {
-  constructor(object, domElement) {
-    super(object, domElement);
-    this.screenSpacePanning = false;
-    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;
+  static async getMineSkin(mineskinId) {
+    return Requests.genericRequest({
+      baseURL: "https://api.mineskin.org",
+      url: "/get/uuid/" + mineskinId
+    }).then((res) => {
+      if (res.status === 200) {
+        return res.data;
+      }
+      return void 0;
+    }).catch((err) => {
+      console.warn(err);
+      return void 0;
+    });
+  }
+  static async getCapesDev(uuid, type = "all") {
+    return Requests.genericRequest({
+      baseURL: "https://api.capes.dev",
+      url: "/load/" + uuid + "/" + type
+    }).then((res) => {
+      if (res.status === 200) {
+        return res.data;
+      }
+      return void 0;
+    }).catch((err) => {
+      console.warn(err);
+      return void 0;
+    });
+  }
+  static getCrafatarSkinUrl(uuid) {
+    return "https://crafatar.com/skins/" + uuid;
+  }
+  static getCrafatarCapeUrl(uuid) {
+    return "https://crafatar.com/capes/" + uuid;
+  }
+  static getMcHeadsSkinUrl(uuid) {
+    return "https://mc-heads.net/skin/" + uuid;
+  }
+  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
@@ -6748,7 +7086,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 = [];
@@ -6800,7 +7138,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];
     }