minerender 2.1.0-alpha.1 → 2.1.0-alpha.11

package/dist/node/index.mjs

@@ -23,14 +23,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   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({
@@ -40,8 +32,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;
       };
@@ -85,7 +77,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];
@@ -96,9 +88,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];
           }
@@ -109,18 +101,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;
   }
 });
 
@@ -149,25 +141,29 @@ var Env = class {
 };
 
 // src/cache/PersistentCache.ts
-var _PersistentCache = class _PersistentCache {
+var PersistentCache = class _PersistentCache {
   constructor(backing) {
     this.backing = backing;
   }
+  static {
+    /** Bump to invalidate every persisted entry. */
+    this.VERSION = 2;
+  }
   static open(name) {
     return Env.provider.openCache(name, _PersistentCache.VERSION);
   }
+  /** Loads a missing entry and stores only non-nullish results. */
   async getOrLoad(key, loader) {
     let v = await this.get(key);
     if (typeof v === "undefined" || v === null) {
       v = await loader(key);
-      await this.put(key, v);
+      if (typeof v !== "undefined" && v !== null) {
+        await this.put(key, v);
+      }
     }
     return v;
   }
 };
-/** Bump to invalidate every persisted entry. */
-_PersistentCache.VERSION = 1;
-var PersistentCache = _PersistentCache;
 
 // src/env/node/NodeCache.ts
 var NodeCache = class extends PersistentCache {
@@ -341,8 +337,7 @@ function serializeImageKey(key) {
   return md5(key.src);
 }
 function serializeBoxGeometryKey(key) {
-  var _a;
-  return md5([key.width, key.height, key.depth, (_a = key.uv) == null ? void 0 : _a.join(":")].join("_"));
+  return md5([key.width, key.height, key.depth, key.uv?.join(":")].join("_"));
 }
 function serializeTextureKey(key) {
   return md5([key.src, key.format, key.rotation].join("$"));
@@ -357,7 +352,61 @@ function serializeMeshKey(key) {
 // src/cache/Caching.ts
 import { Caches } from "@inventivetalent/loading-cache";
 import { Time } from "@inventivetalent/time";
-var Caching = class {
+var Caching = class _Caching {
+  static {
+    this.rawImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(5)).buildAsync();
+  }
+  static {
+    this.imageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
+  }
+  static {
+    this.canvasImageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
+  }
+  static {
+    this.wrappedImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
+  }
+  static {
+    this.boxGeometryCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(20)).build();
+  }
+  static {
+    this.textureCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
+  }
+  static {
+    this.materialCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
+  }
+  static {
+    this.boxMeshCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
+  }
+  static {
+    this.textureAssetCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  }
+  static {
+    this.textureMetaCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  }
+  static {
+    this.rawModelCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  }
+  static {
+    this.mergedModelCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  }
+  static {
+    this.modelTextureAtlasCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  }
+  static {
+    this.blockStateCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
+  }
+  static {
+    this.listAssetCache = _Caching.createAssetCache();
+  }
+  static {
+    this.defaultBlockStatesCache = _Caching.createAssetCache();
+  }
+  static {
+    this.entityModelsCache = _Caching.createAssetCache();
+  }
+  static createAssetCache() {
+    return Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(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 [
@@ -374,7 +423,10 @@ var Caching = class {
       this.rawModelCache,
       this.mergedModelCache,
       this.modelTextureAtlasCache,
-      this.blockStateCache
+      this.blockStateCache,
+      this.listAssetCache,
+      this.defaultBlockStatesCache,
+      this.entityModelsCache
     ];
   }
   static clear() {
@@ -385,8 +437,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) {
@@ -400,20 +452,6 @@ var Caching = class {
     };
   }
 };
-Caching.rawImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(5)).buildAsync();
-Caching.imageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
-Caching.canvasImageDataCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
-Caching.wrappedImageCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(10)).buildAsync();
-Caching.boxGeometryCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(20)).build();
-Caching.textureCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
-Caching.materialCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
-Caching.boxMeshCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).build();
-Caching.textureAssetCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-Caching.textureMetaCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-Caching.rawModelCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-Caching.mergedModelCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-Caching.modelTextureAtlasCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
-Caching.blockStateCache = Caches.builder().expireAfterWrite(Time.minutes(10)).expireAfterAccess(Time.minutes(5)).expirationInterval(Time.seconds(30)).buildAsync();
 
 // src/Geometries.ts
 var Geometries = class _Geometries {
@@ -441,6 +479,7 @@ import { CanvasTexture, Texture as Texture2 } from "three";
 
 // src/texture/TextureLoader.ts
 import { RGBAFormat, Texture } from "three";
+import * as THREE from "three";
 
 // src/canvas/CanvasCompat.ts
 function createImage(width, height) {
@@ -451,9 +490,7 @@ function createCanvas2(width, height) {
 }
 
 // src/request/Requests.ts
-import axios from "axios";
-import { JobQueue } from "jobqu";
-import { Time as Time2 } from "@inventivetalent/time";
+import { JobCancelledError, JobQueue } from "jobqu";
 
 // src/util/log.ts
 var Reset = "\x1B[0m";
@@ -463,198 +500,174 @@ function prefix(prefix2) {
   return `${FgGreen}MR${BgBlack}${prefix2 ?? ""}${Reset}`;
 }
 
-// src/util/BatchedExecutor.ts
-var BatchedExecutor = class {
-  constructor(interval = 1, batch = 30) {
-    this.interval = interval;
-    this.batch = batch;
-    this.queue = [];
-    this.task = setInterval(() => this.run());
-  }
-  submit(task) {
-    this.queue.push(task);
-  }
-  run() {
-    for (let i = 0; i < this.batch; i++) {
-      this.runNext();
-    }
-  }
-  runNext() {
-    let next = this.queue.shift();
-    if (next) next();
+// src/request/Requests.ts
+var p = prefix("Requests");
+var RequestError = class extends Error {
+  constructor(message, response, cause) {
+    super(message);
+    this.response = response;
+    this.cause = cause;
+    this.name = "RequestError";
   }
 };
-
-// src/util/model.ts
-import { AxesHelper, BoxGeometry as BoxGeometry2, EdgesGeometry, LineBasicMaterial, LineSegments, Vector3 as Vector32 } from "three";
-function applyElementRotation(rotation, geometry) {
-  const origin = new Vector32(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 Vector32(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 Vector32(1, 0, 0), toRadians(rotation));
-      break;
-    case "y" /* Y */:
-      obj.rotateOnAxis(new Vector32(0, 1, 0), toRadians(rotation));
-      break;
-    case "z" /* Z */:
-      obj.rotateOnAxis(new Vector32(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 Vector32();
-  box.getSize(size);
-  let boxGeo = new BoxGeometry2(size.x, size.y, size.z, 1, 1, 1);
-  let wireGeo = new EdgesGeometry(boxGeo);
-  let wireMat = new LineBasicMaterial({ color, linewidth: w });
-  let wireframe = new LineSegments(wireGeo, wireMat);
-  obj.add(wireframe);
-  let axes = new AxesHelper(1);
-  obj.add(axes);
-}
-function addWireframeToObject(obj, color = 16777215, w = 2) {
-  let boxGeo = new BoxGeometry2(16, 16, 16, 1, 1, 1);
-  let wireGeo = new EdgesGeometry(boxGeo);
-  let wireMat = new LineBasicMaterial({ color, linewidth: w });
-  let wireframe = new LineSegments(wireGeo, wireMat);
-  obj.add(wireframe);
-  let axes = new AxesHelper(1);
-  obj.add(axes);
-}
-function addWireframeToMesh(geo, mesh, color = 16777215, w = 2) {
-  let wireGeo = new EdgesGeometry(geo);
-  let wireMat = new LineBasicMaterial({ color, linewidth: w });
-  let wireframe = new LineSegments(wireGeo, wireMat);
-  mesh.add(wireframe);
-  let axes = new 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") {
-  axios.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 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 JobCancelledError("ended"));
+  }
+};
+var Requests = class {
+  static {
+    this.genericQueue = new RequestQueue();
+  }
+  static {
+    this.mcAssetRequestQueue = new RequestQueue();
+  }
+  static genericRequest(request) {
+    return this.genericQueue.request(request);
+  }
+  static mcAssetRequest(request) {
+    return this.mcAssetRequestQueue.request(request);
   }
   static setMcAssetRoot(root) {
-    this.mcAssetInstance.defaults.baseURL = root;
+    this.mcAssetRequestQueue.baseURL = root;
   }
+  /** Counts unsettled calls, including retry delays and requests still running after shutdown. */
   static get queueSizes() {
     return {
-      generic: this.genericQueue.size,
-      mcAsset: this.mcAssetRequestQueue.size
+      generic: this.genericQueue.pendingSize,
+      mcAsset: this.mcAssetRequestQueue.pendingSize
     };
   }
   /**
-   * Stops both queue timers. jobqu reschedules itself indefinitely, so a Node process will not
-   * exit until this is called - see {@link shutdown}.
+   * Permanently stops both queues and rejects waiting, retrying, and future requests.
+   * Requests already running can finish. Idle queues hold no timer, so Node can exit without
+   * this cleanup. See {@link shutdown}.
    */
   static end() {
     this.genericQueue.end();
     this.mcAssetRequestQueue.end();
   }
 };
-_Requests.axiosInstance = axios.create({
-  timeout: 5e3
-});
-_Requests.mcAssetInstance = axios.create({
-  timeout: 5e3
-});
-_Requests.genericQueue = new JobQueue((request) => _Requests.axiosInstance.request(request), Time2.millis(10), 1);
-_Requests.mcAssetRequestQueue = new JobQueue((request) => _Requests.mcAssetInstance.request(request), Time2.millis(10), 1);
-var Requests = _Requests;
 
 // src/WrappedImage.ts
 var WrappedImage = class {
@@ -719,29 +732,41 @@ var ImageLoader = class _ImageLoader {
   static async loadAsync(src) {
     return new Promise((resolve, reject) => {
       const image = this._createImage();
-      image.src = src;
       image.onload = () => resolve(image);
-      image.onerror = (err) => reject(err);
+      image.onerror = (err) => reject(err instanceof Error ? err : new Error("Failed to decode image"));
+      image.src = src;
     });
   }
   static loadElement(src, onload, onerr) {
     const image = this._createImage();
-    image.src = src;
     if (onload)
       image.onload = onload;
     if (onerr)
       image.onerror = onerr;
+    image.src = src;
     return image;
   }
   static async loadData(src) {
     console.debug(p2, "loadData", src);
-    return await this.infoToData(await this.getInfo(src));
+    const image = await this.loadCanvasData(src);
+    return image.data.getImageData(0, 0, image.width, image.height);
   }
   static async loadCanvasData(src) {
-    return await this.infoToCanvasData(await this.getInfo(src));
+    const keyStr = serializeImageKey({ src });
+    const info = this.getInfo(src);
+    const cached = Caching.rawImageCache.getIfPresent(keyStr);
+    try {
+      return await this.infoToCanvasData(await info);
+    } catch (err) {
+      if (cached && Caching.rawImageCache.getIfPresent(keyStr) === cached) {
+        Caching.rawImageCache.invalidate(keyStr);
+      }
+      throw err;
+    }
   }
   static async infoToCanvasData(info) {
-    const image = await _ImageLoader.loadAsync(info.src);
+    const type = info.type === "jpg" ? "jpeg" : info.type ?? "png";
+    const image = await _ImageLoader.loadAsync(`data:image/${type};base64,${info.data.toString("base64")}`);
     const canvas = createCanvas2(info.width, info.height);
     const context = canvas.getContext("2d");
     context.drawImage(image, 0, 0);
@@ -752,11 +777,8 @@ var ImageLoader = class _ImageLoader {
     };
   }
   static async infoToData(info) {
-    const image = await _ImageLoader.loadAsync(info.src);
-    const canvas = createCanvas2(info.width, info.height);
-    const context = canvas.getContext("2d");
-    context.drawImage(image, 0, 0);
-    return context.getImageData(0, 0, canvas.width, canvas.height);
+    const image = await this.infoToCanvasData(info);
+    return image.data.getImageData(0, 0, image.width, image.height);
   }
   static async getData(src) {
     const keyStr = serializeImageKey({ src });
@@ -771,38 +793,25 @@ var ImageLoader = class _ImageLoader {
     });
   }
   static async processResponse(response) {
-    const src = response.config.url;
+    const src = response.url;
     const data = Buffer2.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: Buffer2.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: Buffer2.from([0])
-      };
-    });
+    }).then(this.processResponse);
   }
   static async getInfo(src) {
     const keyStr = serializeImageKey({ src });
@@ -824,15 +833,25 @@ var ImageLoader = class _ImageLoader {
 
 // src/texture/TextureLoader.ts
 var TextureLoader = class {
+  static {
+    this.failedTextures = /* @__PURE__ */ new WeakSet();
+  }
+  /** Reports whether image loading failed, so cached textures can be retried. */
+  static hasFailed(texture) {
+    return this.failedTextures.has(texture);
+  }
   static createTexture() {
     return new Texture();
   }
   static loadInBackground(src, format = 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;
@@ -840,9 +859,13 @@ var TextureLoader = class {
   }
   static load(src, format = RGBAFormat, rotation = 0) {
     const texture = new 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;
@@ -851,11 +874,11 @@ var TextureLoader = class {
 };
 
 // src/texture/Textures.ts
-import * as THREE from "three";
+import * as THREE2 from "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;
   }
@@ -866,10 +889,16 @@ var Textures = class _Textures {
     return new Texture2();
   }
   static createCanvasTexture(canvas) {
-    return this.initTextureProps(new CanvasTexture(canvas));
+    const texture = new 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);
     });
@@ -877,7 +906,10 @@ var Textures = class _Textures {
 };
 
 // src/Materials.ts
-var _Materials = class _Materials {
+var Materials = class _Materials {
+  static {
+    this.MISSING_TEXTURE_SRC = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABAAQMAAACQp+OdAAAABlBMVEX/AP8AAACfphTyAAAAFUlEQVQoz2MIhQKGVVAwKjIqQrwIAHRz/wFI17TEAAAAAElFTkSuQmCC";
+  }
   // resolved lazily: as a static field this decoded an image the moment the library was
   // imported, which needs both a DOM and an EnvProvider to already be in place
   static get MISSING_TEXTURE() {
@@ -983,6 +1015,9 @@ var _Materials = class _Materials {
                     gl_FragColor = vec4(lift + color.rgb * light2, 1.0);
 
                 }
+
+                #include <tonemapping_fragment>
+                #include <colorspace_fragment>
             }
         `;
     try {
@@ -1011,6 +1046,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);
     });
@@ -1031,14 +1070,12 @@ var _Materials = class _Materials {
     }
   }
 };
-_Materials.MISSING_TEXTURE_SRC = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABAAQMAAACQp+OdAAAABlBMVEX/AP8AAACfphTyAAAAFUlEQVQoz2MIhQKGVVAwKjIqQrwIAHRz/wFI17TEAAAAAElFTkSuQmCC";
-var Materials = _Materials;
 
 // src/Meshes.ts
-import { Mesh as Mesh2 } from "three";
+import { Mesh } from "three";
 var Meshes = class _Meshes {
   static createBox(key) {
-    return new Mesh2(Geometries.getBox(key.geometry), Materials.getImage(key.material));
+    return new Mesh(Geometries.getBox(key.geometry), Materials.getImage(key.material));
   }
   static getBox(key) {
     const keyStr = serializeMeshKey(key);
@@ -1087,7 +1124,7 @@ var AssetKey = class _AssetKey extends BasicAssetKey {
     this.root = root;
   }
   static parse(assetType, str, origin) {
-    let namespace = (origin == null ? void 0 : origin.namespace) || DEFAULT_NAMESPACE;
+    let namespace = origin?.namespace || DEFAULT_NAMESPACE;
     if (str.includes(":")) {
       let split2 = str.split(":");
       namespace = split2[0];
@@ -1100,8 +1137,8 @@ var AssetKey = class _AssetKey extends BasicAssetKey {
       split.shift();
     }
     let path = split.join("/");
-    let extension = assetType === "textures" ? ".png" : (origin == null ? void 0 : origin.assetType) || ".json";
-    return new _AssetKey(namespace, path, assetType, type, "assets", extension, origin == null ? void 0 : origin.root);
+    let extension = assetType === "textures" ? ".png" : origin?.assetType || ".json";
+    return new _AssetKey(namespace, path, assetType, type, "assets", extension, origin?.root);
   }
   toString() {
     let a = [
@@ -1115,12 +1152,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();
@@ -1145,7 +1182,7 @@ var ModelMerger = class {
       merged = (0, import_ts_deepmerge.default)(merged, parentModel);
     }
     merged = (0, import_ts_deepmerge.default)(merged, model);
-    merged.hierarchy = models.map((m) => m.parent).filter((p13) => `${p13}`);
+    merged.hierarchy = models.map((m) => m.parent).filter((p12) => `${p12}`);
     merged.hierarchy.push(`${merged.parent}`);
     return merged;
   }
@@ -1164,9 +1201,6 @@ var ModelMerger = class {
   }
 };
 
-// src/assets/Models.ts
-import { Memoize } from "typescript-memoize";
-
 // src/assets/source/parser/AssetParsers.ts
 var AssetParser = /* @__PURE__ */ ((AssetParser2) => {
   AssetParser2["MODEL"] = "model";
@@ -1180,14 +1214,14 @@ var AssetParser = /* @__PURE__ */ ((AssetParser2) => {
 })(AssetParser || {});
 
 // src/assets/Models.ts
-var _Models = class _Models {
+var Models = class _Models {
   // opened lazily: touching the store at import time would hit IndexedDB/disk just for loading
   // the library, and would require an EnvProvider before any entry has had a chance to register
   static get PERSISTENT_CACHE() {
     return this._persistentCache ??= PersistentCache.open("minerender-models");
   }
   static async getItemList() {
-    return AssetLoader.get(new AssetKey(
+    const key = new AssetKey(
       DEFAULT_NAMESPACE,
       "_list",
       "models",
@@ -1195,7 +1229,10 @@ var _Models = class _Models {
       "assets",
       ".json",
       DEFAULT_ROOT
-    ), "list" /* LIST */).then((r) => (r == null ? void 0 : r.files) ?? []);
+    );
+    return Caching.listAssetCache.get(key.serialize(), () => {
+      return AssetLoader.get(key, "list" /* LIST */);
+    }).then((r) => r?.files ?? []);
   }
   static async loadAndMerge(key) {
     const model = await this.getRaw(key);
@@ -1242,19 +1279,15 @@ var _Models = class _Models {
     return this.PERSISTENT_CACHE.clear();
   }
 };
-__decorateClass([
-  Memoize()
-], _Models, "getItemList", 1);
-var Models = _Models;
 
 // src/assets/BlockStates.ts
-import { Memoize as Memoize2 } from "typescript-memoize";
 var BlockStates = class {
   static get PERSISTENT_CACHE() {
     return this._persistentCache ??= PersistentCache.open("minerender-blockstates");
   }
+  // BlockState names are hardcoded
   static async getList() {
-    return AssetLoader.get(new AssetKey(
+    const key = new AssetKey(
       DEFAULT_NAMESPACE,
       "_list",
       "blockstates",
@@ -1262,11 +1295,16 @@ var BlockStates = class {
       "assets",
       ".json",
       DEFAULT_ROOT
-    ), "list" /* LIST */).then((r) => (r == null ? void 0 : 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();
@@ -1305,12 +1343,6 @@ var BlockStates = class {
     await this.PERSISTENT_CACHE.clear();
   }
 };
-__decorateClass([
-  Memoize2()
-], BlockStates, "getList", 1);
-__decorateClass([
-  Memoize2()
-], BlockStates, "getDefaultStates", 1);
 var DefaultBlockStates = class {
 };
 
@@ -1337,23 +1369,236 @@ var AssetSource = class {
   constructor() {
   }
 };
+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/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/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/assets/source/HostedAssetSource.ts
-var import_ts_deepmerge2 = __toESM(require_dist());
-var p3 = prefix("HostedAssetSource");
+// src/util/model.ts
+import { AxesHelper, BoxGeometry as BoxGeometry2, EdgesGeometry, LineBasicMaterial, LineSegments, Vector3 as Vector32 } from "three";
+function applyElementRotation(rotation, geometry) {
+  const origin = new Vector32(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 Vector32(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 Vector32(1, 0, 0), toRadians(rotation));
+      break;
+    case "y" /* Y */:
+      obj.rotateOnAxis(new Vector32(0, 1, 0), toRadians(rotation));
+      break;
+    case "z" /* Z */:
+      obj.rotateOnAxis(new Vector32(0, 0, 1), toRadians(rotation));
+      break;
+  }
+}
+function addBox3WireframeToObject(box, obj, color = 16777215, w = 2) {
+  let size = new Vector32();
+  box.getSize(size);
+  let boxGeo = new BoxGeometry2(size.x, size.y, size.z, 1, 1, 1);
+  let wireGeo = new EdgesGeometry(boxGeo);
+  let wireMat = new LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new LineSegments(wireGeo, wireMat);
+  obj.add(wireframe);
+  let axes = new AxesHelper(1);
+  obj.add(axes);
+}
+function addWireframeToObject(obj, color = 16777215, w = 2) {
+  let boxGeo = new BoxGeometry2(16, 16, 16, 1, 1, 1);
+  let wireGeo = new EdgesGeometry(boxGeo);
+  let wireMat = new LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new LineSegments(wireGeo, wireMat);
+  obj.add(wireframe);
+  let axes = new AxesHelper(1);
+  obj.add(axes);
+}
+function addWireframeToMesh(geo, mesh, color = 16777215, w = 2) {
+  let wireGeo = new EdgesGeometry(geo);
+  let wireMat = new LineBasicMaterial({ color, linewidth: w });
+  let wireframe = new LineSegments(wireGeo, wireMat);
+  mesh.add(wireframe);
+  let axes = new 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 {
+var HostedAssetSource = class _HostedAssetSource extends AssetSource {
+  static {
+    this.MODEL = {
+      config(request) {
+      },
+      parse(response) {
+        return response.data;
+      }
+    };
+  }
+  static {
+    this.BLOCKSTATE = {
+      config(request) {
+      },
+      parse(response) {
+        return response.data;
+      }
+    };
+  }
+  static {
+    this.META = {
+      config(request) {
+      },
+      parse(response) {
+        return response.data;
+      }
+    };
+  }
+  static {
+    this.NBT = {
+      config(request) {
+        request.responseType = "arraybuffer";
+      },
+      parse(response) {
+        return NBTHelper.fromBuffer(Buffer.from(response.data));
+      }
+    };
+  }
+  static {
+    this.IMAGE = {
+      config(request) {
+        request.responseType = "arraybuffer";
+      },
+      async parse(response) {
+        return await ImageLoader.processResponse(response);
+      }
+    };
+  }
+  static {
+    this.LIST = {
+      config(request) {
+      },
+      parse(response) {
+        return response.data;
+      }
+    };
+  }
+  static {
+    this.JSON = {
+      config(request) {
+      },
+      parse(response) {
+        return response.data;
+      }
+    };
+  }
+  static {
+    this.PARSER_MAP = /* @__PURE__ */ new Map([
+      ["model" /* MODEL */, _HostedAssetSource.MODEL],
+      ["blockstate" /* BLOCKSTATE */, _HostedAssetSource.BLOCKSTATE],
+      ["meta" /* META */, _HostedAssetSource.META],
+      ["nbt" /* NBT */, _HostedAssetSource.NBT],
+      ["image" /* IMAGE */, _HostedAssetSource.IMAGE],
+      ["list" /* LIST */, _HostedAssetSource.LIST],
+      ["json" /* JSON */, _HostedAssetSource.JSON]
+    ]);
+  }
   async loadOrRetryWithDefaults(key, parser) {
     const direct = await this.load(key, parser);
     if (typeof direct !== "undefined") {
@@ -1388,31 +1633,25 @@ var _HostedAssetSource = class _HostedAssetSource extends AssetSource {
     console.info(p3, "Loading", key);
     const url = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
     console.debug(p3, url);
-    let req = {
-      url
-    };
-    parser.config(req);
-    return await Requests.mcAssetRequest(req).then((response) => {
-      if (response && response.data) {
-        try {
-          return parser.parse(response);
-        } catch (e) {
-          console.warn("Parser failed to process response", response, e);
-          throw e;
-        }
-      }
-      return void 0;
-    }).catch((err) => {
-      if (err.response) {
-        let response = err.response;
-        if (response.status === 404) {
-          console.debug(p3, key, "not found");
+    const request = { url };
+    try {
+      parser.config(request);
+      let response;
+      try {
+        response = await Requests.mcAssetRequest(request);
+      } catch (cause) {
+        if (cause instanceof RequestError && cause.response?.status === 404) {
           return void 0;
         }
+        throw cause;
       }
-      console.debug(p3, "Failed to load", key, err == null ? void 0 : err.message);
-      return void 0;
-    });
+      if (response.data === void 0) {
+        throw new Error("Asset response has no data");
+      }
+      return await parser.parse(response);
+    } catch (cause) {
+      throw new AssetLoadError(this, key, request.url, cause);
+    }
   }
   assetBasePath(key) {
     return `${key.root ?? this.root ?? AssetLoader.ROOT}/${key.rootType !== void 0 ? key.rootType + "/" : ""}${key.namespace !== void 0 ? key.namespace + "/" : ""}${key.assetType !== void 0 ? key.assetType + "/" : ""}`;
@@ -1436,67 +1675,6 @@ var _HostedAssetSource = class _HostedAssetSource extends AssetSource {
     return this.load(key, responseParser);
   }
 };
-_HostedAssetSource.MODEL = {
-  config(request) {
-  },
-  parse(response) {
-    return response.data;
-  }
-};
-_HostedAssetSource.BLOCKSTATE = {
-  config(request) {
-  },
-  parse(response) {
-    return response.data;
-  }
-};
-_HostedAssetSource.META = {
-  config(request) {
-  },
-  parse(response) {
-    return response.data;
-  }
-};
-_HostedAssetSource.NBT = {
-  config(request) {
-    request.responseType = "arraybuffer";
-  },
-  parse(response) {
-    return NBTHelper.fromBuffer(Buffer.from(response.data));
-  }
-};
-_HostedAssetSource.IMAGE = {
-  config(request) {
-    request.responseType = "arraybuffer";
-  },
-  async parse(response) {
-    return await ImageLoader.processResponse(response);
-  }
-};
-_HostedAssetSource.LIST = {
-  config(request) {
-  },
-  parse(response) {
-    return response.data;
-  }
-};
-_HostedAssetSource.JSON = {
-  config(request) {
-  },
-  parse(response) {
-    return response.data;
-  }
-};
-_HostedAssetSource.PARSER_MAP = /* @__PURE__ */ new Map([
-  ["model" /* MODEL */, _HostedAssetSource.MODEL],
-  ["blockstate" /* BLOCKSTATE */, _HostedAssetSource.BLOCKSTATE],
-  ["meta" /* META */, _HostedAssetSource.META],
-  ["nbt" /* NBT */, _HostedAssetSource.NBT],
-  ["image" /* IMAGE */, _HostedAssetSource.IMAGE],
-  ["list" /* LIST */, _HostedAssetSource.LIST],
-  ["json" /* JSON */, _HostedAssetSource.JSON]
-]);
-var HostedAssetSource = _HostedAssetSource;
 
 // src/assets/source/archive/BrowserArchiveProxy.ts
 import { BlobReader, BlobWriter, ZipReader } from "@zip.js/zip.js";
@@ -1519,7 +1697,6 @@ var BrowserArchiveProxy = class {
 };
 
 // src/assets/source/archive/ArchiveAssetSource.ts
-var p4 = prefix("ArchiveAssetSource");
 var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
   constructor(archiveProxy) {
     super();
@@ -1538,74 +1715,31 @@ var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
   }
   async get(key, parser) {
     const responseParser = HostedAssetSource.PARSER_MAP.get(parser);
-    console.log("ArchiveAssetSource.get", key, parser);
-    let entries = await this.getEntries();
-    const path = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
-    console.log(path);
-    const entry = await this.getEntry(path);
-    console.log(entry);
-    if (!entry) {
-      return void 0;
-    }
-    let blob = await entry.getData();
-    const url = URL.createObjectURL(blob);
-    console.log(url);
-    let req = {
-      url
-    };
-    responseParser.config(req);
-    return Requests.genericRequest(req).then((response) => {
-      if (response && response.data) {
-        try {
-          return responseParser.parse(response);
-        } catch (e) {
-          console.warn("Parser failed to process response", response, e);
-          throw e;
-        }
-      }
-      return void 0;
-    }).catch((err) => {
-      if (err.response) {
-        let response = err.response;
-        if (response.status === 404) {
-          console.debug(p4, key, "not found");
-          return void 0;
-        }
-      }
-      console.debug(p4, "Failed to load", key, err == null ? void 0 : err.message);
-      return void 0;
-    });
+    return this.load(key, responseParser);
   }
-  //TODO: abstract this
   async load(key, parser) {
-    console.info(p4, "Loading", key);
-    const url = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
-    console.debug(p4, url);
-    let req = {
-      url
-    };
-    parser.config(req);
-    return await Requests.genericRequest(req).then((response) => {
-      if (response && response.data) {
-        try {
-          return parser.parse(response);
-        } catch (e) {
-          console.warn("Parser failed to process response", response, e);
-          throw e;
-        }
+    const path = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
+    let url;
+    try {
+      const entry = await this.getEntry(path);
+      if (!entry) {
+        return void 0;
       }
-      return void 0;
-    }).catch((err) => {
-      if (err.response) {
-        let response = err.response;
-        if (response.status === 404) {
-          console.debug(p4, key, "not found");
-          return void 0;
-        }
+      url = URL.createObjectURL(await entry.getData());
+      const request = { url };
+      parser.config(request);
+      const response = await Requests.genericRequest(request);
+      if (response.data === void 0) {
+        throw new Error("Asset response has no data");
       }
-      console.debug(p4, "Failed to load", key, err == null ? void 0 : err.message);
-      return void 0;
-    });
+      return await parser.parse(response);
+    } catch (cause) {
+      throw new AssetLoadError(this, key, path, cause);
+    } finally {
+      if (url !== void 0) {
+        URL.revokeObjectURL(url);
+      }
+    }
   }
   assetBasePath(key) {
     return `${key.rootType !== void 0 ? key.rootType + "/" : ""}${key.namespace !== void 0 ? key.namespace + "/" : ""}${key.assetType !== void 0 ? key.assetType + "/" : ""}`;
@@ -1613,18 +1747,23 @@ var ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
 };
 
 // src/assets/AssetLoader.ts
-var import_ts_deepmerge3 = __toESM(require_dist());
-var p5 = prefix("AssetLoader");
-var _AssetLoader = class _AssetLoader {
+var p4 = prefix("AssetLoader");
+var AssetLoader = class {
+  static {
+    this.ROOT = DEFAULT_ROOT;
+  }
+  static {
+    this._SOURCES = [];
+  }
   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);
@@ -1636,8 +1775,11 @@ var _AssetLoader = class _AssetLoader {
     }
     return void 0;
   }
+  static {
+    this.addSource("mcassets-fallback", new HostedAssetSource("https://raw.githubusercontent.com/InventivetalentDev/minerender-fallback-assets/master", { retryDefaults: false }));
+    this.addSource("mcassets", new HostedAssetSource(DEFAULT_ROOT, { retryDefaults: false }));
+  }
   static async getAll(key, parser) {
-    console.log(this._SOURCES);
     let promises = [];
     for (const source of this._SOURCES) {
       promises.push(source.source.get(key, parser));
@@ -1646,31 +1788,18 @@ 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 sources = [...this._SOURCES];
+    for (const source of sources) {
+      const result = await source.source.get(key, parser);
+      if (result !== void 0) {
+        return result;
       }
-      return void 0;
-    });
+    }
+    return void 0;
   }
 };
-_AssetLoader.ROOT = DEFAULT_ROOT;
-_AssetLoader._SOURCES = [];
-_AssetLoader.addSource("mcassets-fallback", new HostedAssetSource("https://raw.githubusercontent.com/InventivetalentDev/minerender-fallback-assets/master", { retryDefaults: false }));
-_AssetLoader.addSource("mcassets", new HostedAssetSource(DEFAULT_ROOT, { retryDefaults: false }));
-var AssetLoader = _AssetLoader;
 
 // src/assets/ModelTextures.ts
 var ModelTextures = class {
@@ -1678,11 +1807,21 @@ var ModelTextures = class {
     return this._persistentMetaCache ??= PersistentCache.open("minerender-texturemeta");
   }
   static async get(key) {
-    const asset = await this.preload(key);
-    if (asset) {
-      return ImageLoader.infoToCanvasData(asset);
+    const keyStr = key.serialize();
+    const pending = this.preload(key);
+    const cached = Caching.textureAssetCache.getIfPresent(keyStr);
+    try {
+      const asset = await pending;
+      if (asset) {
+        return await ImageLoader.infoToCanvasData(asset);
+      }
+      return void 0;
+    } catch (err) {
+      if (cached && Caching.textureAssetCache.getIfPresent(keyStr) === cached) {
+        Caching.textureAssetCache.invalidate(keyStr);
+      }
+      throw err;
     }
-    return void 0;
   }
   static async preload(key) {
     const keyStr = key.serialize();
@@ -1756,7 +1895,28 @@ var CanvasImage = class {
 };
 
 // src/Ticker.ts
-var _Ticker = class _Ticker {
+var Ticker = class _Ticker {
+  static {
+    this.TPS = 20;
+  }
+  static {
+    this.counter = 0;
+  }
+  static {
+    this._tickers = /* @__PURE__ */ new Map();
+  }
+  static {
+    this.oneSecondTps = 0;
+  }
+  static {
+    this.oneSecondTicks = 0;
+  }
+  static {
+    this.fiveSecondTps = 0;
+  }
+  static {
+    this.fiveSecondTicks = 0;
+  }
   static schedule(fn, ms) {
     const handle = setInterval(fn, ms);
     const unref = handle.unref;
@@ -1818,14 +1978,6 @@ var _Ticker = class _Ticker {
     this._tickers.clear();
   }
 };
-_Ticker.TPS = 20;
-_Ticker.counter = 0;
-_Ticker._tickers = /* @__PURE__ */ new Map();
-_Ticker.oneSecondTps = 0;
-_Ticker.oneSecondTicks = 0;
-_Ticker.fiveSecondTps = 0;
-_Ticker.fiveSecondTicks = 0;
-var Ticker = _Ticker;
 
 // src/texture/TextureAtlas.ts
 var TextureAtlas = class {
@@ -1851,6 +2003,9 @@ var TextureAtlas = class {
 
 // src/model/ModelGenerator.ts
 var ModelGenerator = class {
+  static {
+    this.ITEM_LAYERS = ["layer0", "layer1", "layer2", "layer3", "layer4"];
+  }
   static generateItemModel(imageData, layer) {
     const mainElement = {
       from: [0, 0, 7.5],
@@ -1870,10 +2025,9 @@ var ModelGenerator = class {
     return [mainElement];
   }
 };
-ModelGenerator.ITEM_LAYERS = ["layer0", "layer1", "layer2", "layer3", "layer4"];
 
 // src/UVMapper.ts
-var p6 = prefix("UVMapper");
+var p5 = prefix("UVMapper");
 var DEFAULT_UV = [0, 0, 16, 16];
 var X = 0;
 var Y = 1;
@@ -2046,12 +2200,11 @@ var UVMapper = class {
     return [tl, tr, bl, br];
   }
   static async createAtlas(originalModel) {
-    var _a;
     const textureMap = {};
     const metaMap = {};
     const model = { ...originalModel };
     const isItemModel = !("elements" in model);
-    console.debug(p6, "Creating Atlas for", model.key);
+    console.debug(p5, "Creating Atlas for", model.key);
     if (model.textures) {
       const promises = [];
       const uniqueTextureNames = [];
@@ -2065,7 +2218,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);
@@ -2077,7 +2230,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 = {};
@@ -2097,7 +2250,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");
@@ -2126,16 +2279,15 @@ var UVMapper = class {
           if (texture.animated) {
             hasAnimation = true;
             const meta = metaMap[textureKey];
-            const frameTime = ((_a = meta == null ? void 0 : meta.animation) == null ? void 0 : _a.frametime) ?? 1;
+            const frameTime = meta?.animation?.frametime ?? 1;
             console.log(meta);
             console.log(frameTime);
             let t = 0;
             let f = 0;
             animatorFunctions[textureKey] = () => {
-              var _a2;
               if (t++ >= frameTime) {
                 t = 0;
-                const frames = (_a2 = meta == null ? void 0 : meta.animation) == null ? void 0 : _a2.frames;
+                const frames = meta?.animation?.frames;
                 const frame = frames ? frames[f] : f;
                 image.putData(texture.getFrameSectionData(frame), x, y, 0, 0, maxWidth, maxWidth);
                 f++;
@@ -2153,10 +2305,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];
@@ -2164,7 +2316,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) {
       }
@@ -2224,7 +2376,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;
   }
@@ -2362,17 +2514,20 @@ function shutdown() {
 }
 
 // src/assets/Entities.ts
-import { Memoize as Memoize3 } from "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() {
@@ -2418,12 +2573,6 @@ var Entities = class {
     };
   }
 };
-__decorateClass([
-  Memoize3()
-], Entities, "getBlockEntityModels", 1);
-__decorateClass([
-  Memoize3()
-], Entities, "getEntityModels", 1);
 var EntityModels = class {
 };
 var BlockEntityModels = class {
@@ -2487,18 +2636,26 @@ var MineRenderError = class _MineRenderError extends Error {
 };
 
 // src/renderer/SceneObject.ts
-var import_ts_deepmerge4 = __toESM(require_dist());
-var p7 = prefix("SceneObject");
-var _SceneObject = class _SceneObject extends Object3D2 {
+var import_ts_deepmerge3 = __toESM(require_dist());
+var p6 = prefix("SceneObject");
+var SceneObject = class _SceneObject extends Object3D2 {
   constructor(options) {
     super();
     this.isSceneObject = true;
     this.materialCallbacks = {};
     this._isInstanced = false;
     this._instanceCounter = 0;
-    this.options = (0, import_ts_deepmerge4.default)({}, _SceneObject.DEFAULT_OPTIONS, options ?? {});
+    this.options = (0, import_ts_deepmerge3.default)({}, _SceneObject.DEFAULT_OPTIONS, options ?? {});
     console.log("SceneObject options", this.options);
   }
+  static {
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge3.default)({}, {
+      instanceMeshes: true,
+      maxInstanceCount: 50,
+      mergeMeshes: true,
+      wireframe: false
+    });
+  }
   set scene(scene) {
     if (!!this._scene) throw new MineRenderError("Scene already set");
     this._scene = scene;
@@ -2667,9 +2824,9 @@ var _SceneObject = class _SceneObject extends Object3D2 {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const i = this._instanceCounter++;
     this.setMatrixAt(i, new Matrix42());
-    console.debug(p7, "nextInstance " + i);
+    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++;
@@ -2840,34 +2997,29 @@ var _SceneObject = class _SceneObject extends Object3D2 {
     this.notifyDirty();
   }
   removeFromScene() {
-    var _a;
-    (_a = this._scene) == null ? void 0 : _a.remove(this);
+    this._scene?.remove(this);
     this.notifyDirty();
   }
   //</editor-fold>
 };
-_SceneObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, {
-  instanceMeshes: true,
-  maxInstanceCount: 50,
-  mergeMeshes: true,
-  wireframe: false
-});
-var SceneObject = _SceneObject;
 function isSceneObject(obj) {
   return obj.isSceneObject;
 }
 
 // src/entity/scene/EntityObject.ts
-var import_ts_deepmerge5 = __toESM(require_dist());
+var import_ts_deepmerge4 = __toESM(require_dist());
 import { Object3D as Object3D3 } from "three";
-import * as THREE2 from "three";
+import * as THREE3 from "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 ?? {});
+  }
+  static {
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS, {});
   }
   async init() {
     this.createMeshes();
@@ -2876,19 +3028,21 @@ var EntityObject = class extends SceneObject {
   dispose() {
     super.dispose();
   }
-  async loadTextures() {
-    var _a;
-    this.imageData = await ModelTextures.get(new AssetKey(
-      ((_a = this.entity.key) == null ? void 0 : _a.namespace) ?? DEFAULT_NAMESPACE,
+  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.
       "textures",
       "entity",
       "assets",
       ".png"
-    ));
+    );
   }
-  //TODO: abstract this, since extracted model data can be used for entities, blocks, players
+  async loadTextures() {
+    this.imageData = await ModelTextures.get(this.textureKey);
+  }
+  //TODO: abstract this, since extracted model data can be used for entities, blocks, players
   createMeshes(force = false) {
     if (this.meshesCreated && !force) return;
     const mat = Materials.MISSING_TEXTURE;
@@ -2905,8 +3059,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);
@@ -2919,24 +3073,25 @@ var EntityObject = class extends SceneObject {
     this.meshesCreated = true;
   }
   async applyTextures() {
-    var _a;
-    const textureAsset = await ModelTextures.preload(new AssetKey(
-      ((_a = this.entity.key) == null ? void 0 : _a.namespace) ?? DEFAULT_NAMESPACE,
-      this.entity.key.path,
-      "textures",
-      "entity",
-      "assets",
-      ".png"
-    ));
-    if (textureAsset) {
-      let mat = Materials.getImage({ texture: { src: textureAsset.src } });
-      this.iterateAllMeshes((mesh) => {
-        mesh.material = mat;
-      });
-    }
+    const assetKeyStr = this.textureKey.serialize();
+    const keyStr = `entity:${assetKeyStr}`;
+    let mat = Caching.materialCache.getIfPresent(keyStr);
+    if (!mat) {
+      const pending = this.loadTextures();
+      const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
+      await pending;
+      if (!this.imageData) return;
+      const canvas = this.imageData.data.canvas;
+      const createMaterial = () => Materials.createBasicCanvasMaterial(canvas);
+      mat = cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
+      this.imageData = void 0;
+    }
+    this.iterateAllMeshes((mesh) => {
+      mesh.material = mat;
+    });
+    this.notifyDirty();
   }
 };
-EntityObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge5.default)({}, SceneObject.DEFAULT_OPTIONS, {});
 function isEntityObject(obj) {
   return obj.isEntityObject;
 }
@@ -2948,7 +3103,7 @@ var GuiObject = class extends SceneObject {
 
 // src/inspector/SceneInspector.ts
 import { Raycaster, Vector2 as Vector22 } from "three";
-var p8 = prefix("SceneInspector");
+var p7 = prefix("SceneInspector");
 var help = "<span>Ctrl+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
@@ -2977,8 +3132,7 @@ var SceneInspector = class {
     return out;
   }
   onClick(event) {
-    var _a;
-    if (((_a = event.target) == null ? void 0 : _a.nodeName) !== "CANVAS") return;
+    if (event.target?.nodeName !== "CANVAS") return;
     if (!event.ctrlKey) return;
     setTimeout(() => {
       this.mouse.x = event.clientX / window.innerWidth * 2 - 1;
@@ -3018,7 +3172,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) {
@@ -3316,7 +3470,7 @@ var SceneStatsDisplay = class {
 };
 
 // src/instance/InstanceManager.ts
-var p9 = prefix("InstanceManager");
+var p8 = prefix("InstanceManager");
 var InstanceManager = class {
   constructor() {
     this.isInstanceManager = true;
@@ -3324,7 +3478,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;
@@ -3333,13 +3487,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) {
@@ -3938,26 +4096,28 @@ function computeMorphedAttributes(object) {
 }
 
 // src/model/scene/ModelObject.ts
-var import_ts_deepmerge6 = __toESM(require_dist());
-var p10 = prefix("ModelObject");
-var _ModelObject = class _ModelObject extends SceneObject {
+var import_ts_deepmerge5 = __toESM(require_dist());
+var p9 = prefix("ModelObject");
+var ModelObject = class _ModelObject extends SceneObject {
   constructor(originalModel, options) {
     super(options);
     this.originalModel = originalModel;
     this.isModelObject = true;
     this.meshesCreated = false;
-    this.options = (0, import_ts_deepmerge6.default)({}, _ModelObject.DEFAULT_OPTIONS, options ?? {});
+    this.options = (0, import_ts_deepmerge5.default)({}, _ModelObject.DEFAULT_OPTIONS, options ?? {});
     console.log("ModelObject options", this.options);
   }
+  static {
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge5.default)({}, SceneObject.DEFAULT_OPTIONS, {});
+  }
   async init() {
     await this.loadTextures();
     this.createMeshes();
     this.applyTextures();
   }
   dispose() {
-    var _a;
     super.dispose();
-    (_a = this.atlas) == null ? void 0 : _a.dispose();
+    this.atlas?.dispose();
   }
   get textureAtlas() {
     return this.atlas;
@@ -3967,13 +4127,12 @@ var _ModelObject = class _ModelObject extends SceneObject {
     this.atlas = await UVMapper.getAtlas(this.originalModel);
   }
   createMeshes(force = false) {
-    var _a;
     if (this.meshesCreated && !force) return;
     const mat = Materials.MISSING_TEXTURE;
     let allGeos = [];
     if (this.atlas) {
       if (this.atlas.model.elements) {
-        (_a = this.atlas.model.elements) == null ? void 0 : _a.forEach((el) => {
+        this.atlas.model.elements?.forEach((el) => {
           const elGeo = this._getBoxGeometryFromElement(el).clone();
           elGeo.applyMatrix4(new Matrix45().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 Matrix45().makeTranslation(el.from[0], el.from[1], el.from[2]));
@@ -3991,10 +4150,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;
@@ -4046,17 +4205,15 @@ var _ModelObject = class _ModelObject extends SceneObject {
     }
   }
 };
-_ModelObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge6.default)({}, SceneObject.DEFAULT_OPTIONS, {});
-var ModelObject = _ModelObject;
 function isModelObject(obj) {
   return obj.isModelObject;
 }
 
 // src/model/block/scene/BlockObject.ts
-var import_ts_deepmerge7 = __toESM(require_dist());
+var import_ts_deepmerge6 = __toESM(require_dist());
 import { Euler as Euler3, Matrix4 as Matrix46, Vector3 as Vector36 } from "three";
-var p11 = prefix("BlockObject");
-var _BlockObject = class _BlockObject extends SceneObject {
+var p10 = prefix("BlockObject");
+var BlockObject = class _BlockObject extends SceneObject {
   constructor(blockState, options) {
     super(options);
     this.blockState = blockState;
@@ -4069,11 +4226,16 @@ var _BlockObject = class _BlockObject extends SceneObject {
     this._instanceModel = [];
     this._variants = [];
     this._models = [];
-    this.options = (0, import_ts_deepmerge7.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
+    this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
+  }
+  static {
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge6.default)({}, ModelObject.DEFAULT_OPTIONS, {
+      applyDefaultState: true
+    });
   }
   async init() {
     if (this.options.applyDefaultState) {
-      const defaultState = this.blockState.key ? BlockStates.getDefaultState(this.blockState.key) : void 0;
+      const defaultState = this.blockState.key ? await BlockStates.getDefaultState(this.blockState.key) : void 0;
       if (defaultState && Object.keys(defaultState).length > 0) {
         const state = {};
         for (let k in defaultState) {
@@ -4149,7 +4311,7 @@ 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) {
@@ -4358,10 +4520,6 @@ var _BlockObject = class _BlockObject extends SceneObject {
   //TODO: should override rotation + scale methods
   //TODO
 };
-_BlockObject.DEFAULT_OPTIONS = (0, import_ts_deepmerge7.default)({}, ModelObject.DEFAULT_OPTIONS, {
-  applyDefaultState: true
-});
-var BlockObject = _BlockObject;
 function isBlockObject(obj) {
   return obj.isBlockObject;
 }
@@ -4386,11 +4544,10 @@ var StructureParser = class {
       throw new MineRenderError("Structure does not have palette(s)");
     }
     const blocks = nbt.blocks.value.value.map((block) => {
-      var _a;
       const state = palette.value.value[block.state.value];
       if (state.Name.value === "minecraft:air") return void 0;
       const props = {};
-      for (let k in (_a = state.Properties) == null ? void 0 : _a.value) {
+      for (let k in state.Properties?.value) {
         props[k] = state.Properties.value[k].value;
       }
       return {
@@ -4409,7 +4566,7 @@ var StructureParser = class {
 
 // src/renderer/MineRenderScene.ts
 import { Scene as Scene2 } from "three";
-var import_ts_deepmerge9 = __toESM(require_dist());
+var import_ts_deepmerge8 = __toESM(require_dist());
 
 // src/skin/SkinPart.ts
 var SkinPart = /* @__PURE__ */ ((SkinPart2) => {
@@ -5140,7 +5297,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();
@@ -5148,7 +5305,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();
@@ -5252,31 +5409,64 @@ var SkinObject = class extends SceneObject {
 };
 
 // src/renderer/MineRenderScene.ts
-var _MineRenderScene = class _MineRenderScene extends Scene2 {
+var MineRenderScene = class _MineRenderScene extends Scene2 {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
     this.stats = new SceneStats();
     this.instanceManager = new InstanceManager();
     this.dirty = true;
-    this.options = (0, import_ts_deepmerge9.default)({}, _MineRenderScene.DEFAULT_OPTIONS, options ?? {});
+    this.observedObjects = /* @__PURE__ */ new Set();
+    this.onObjectChange = (event) => {
+      if (event.target?.parent === this) {
+        this.dirty = true;
+      }
+    };
+    this.options = (0, import_ts_deepmerge8.default)({}, _MineRenderScene.DEFAULT_OPTIONS, options ?? {});
   }
-  add(...object) {
-    this.dirty = true;
-    this.stats.objectCount += object.length;
-    for (let obj of object) {
-      if (isSceneObject(obj)) {
-        this.stats.sceneObjectCount++;
+  static {
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge8.default)({}, {});
+  }
+  add(...objects) {
+    for (const object of objects) {
+      this.dirty = true;
+      try {
+        super.add(object);
+      } finally {
+        if (object?.isObject3D && object !== this) {
+          this.updateObjectRegistration(object, object.parent === this);
+        }
       }
-      obj.addEventListener("change", (event) => {
-        this.dirty = true;
-      });
     }
-    return super.add(...object);
+    return this;
   }
-  remove(...object) {
-    this.dirty = true;
-    return super.remove(...object);
+  remove(...objects) {
+    for (const object of objects) {
+      if (!this.children.includes(object)) continue;
+      this.dirty = true;
+      this.updateObjectRegistration(object, false);
+      try {
+        super.remove(object);
+      } finally {
+        this.updateObjectRegistration(object, object.parent === this);
+      }
+    }
+    return this;
+  }
+  updateObjectRegistration(object, attached) {
+    if (this.observedObjects.has(object) === attached) return;
+    if (attached) {
+      this.observedObjects.add(object);
+      object.addEventListener("change", this.onObjectChange);
+    } else {
+      this.observedObjects.delete(object);
+      object.removeEventListener("change", this.onObjectChange);
+    }
+    const change = attached ? 1 : -1;
+    this.stats.objectCount += change;
+    if (isSceneObject(object)) {
+      this.stats.sceneObjectCount += change;
+    }
   }
   async initAndAdd(...object) {
     this.dirty = true;
@@ -5286,13 +5476,12 @@ var _MineRenderScene = class _MineRenderScene extends Scene2 {
     return this.add(...object);
   }
   async addSceneObject(asset, objectSupplier, _options, parent = this) {
-    var _a, _b;
     console.log("addSceneObject", asset);
     console.log("parent", parent);
     console.log(_options);
     this.dirty = true;
     const obj = await objectSupplier();
-    if (((_a = obj == null ? void 0 : obj.options) == null ? void 0 : _a.instanceMeshes) && asset.key && ((_b = asset.key) == null ? void 0 : _b.assetType) === "models") {
+    if (obj?.options?.instanceMeshes && asset.key && asset.key?.assetType === "models") {
       console.log("instanceMeshes + key");
       const key = asset.key.serialize();
       return this.instanceManager.getOrCreate(key, async () => {
@@ -5332,422 +5521,30 @@ var _MineRenderScene = class _MineRenderScene extends Scene2 {
     return this.addSceneObject(entity, () => new EntityObject(entity, options), options, parent);
   }
 };
-_MineRenderScene.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {});
-var MineRenderScene = _MineRenderScene;
 function isMineRenderScene(obj) {
   return obj.isMineRenderScene;
 }
 
 // src/renderer/Renderer.ts
-import { AxesHelper as AxesHelper3, GridHelper, LinearEncoding, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera, Vector3 as Vector37, WebGLRenderer } from "three";
-var import_ts_deepmerge10 = __toESM(require_dist());
+import { AxesHelper as AxesHelper3, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace3, Vector3 as Vector38, WebGLRenderer } from "three";
+var import_ts_deepmerge9 = __toESM(require_dist());
 import Stats from "stats.js";
 import { EffectComposer, RenderPass } from "postprocessing";
-var _Renderer = class _Renderer {
-  constructor(options) {
-    this._dirty = true;
-    this._animationTimer = void 0;
-    this._animationFrame = void 0;
-    this._resizeListener = void 0;
-    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 Stats();
-      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 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 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 WebGLRenderer({
-      antialias: this.options.render.antialias,
-      alpha: true,
-      powerPreference: "high-performance",
-      depth: true
-    });
-    renderer.setClearColor(0, 0);
-    renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = PCFSoftShadowMap;
-    renderer.outputEncoding = LinearEncoding;
-    renderer.setSize(this.viewWidth, this.viewHeight);
-    return renderer;
-  }
-  createComposer() {
-    const composer = new EffectComposer(this.renderer);
-    if (!this.options.composer.enabled) return composer;
-    composer.setSize(this.viewWidth, this.viewHeight);
-    composer.addPass(new RenderPass(this.scene, this.camera));
-    return composer;
-  }
-  //</editor-fold>
-  init() {
-    if (typeof window["__THREE_DEVTOOLS__"] !== "undefined") {
-      window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
-    }
-    if (this.options.debug.grid) {
-      const gridHelper = new GridHelper(128, 16);
-      this.scene.add(gridHelper);
-      const gridHelper2 = new GridHelper(128, 16);
-      gridHelper2.rotation.x = 90 * (Math.PI / 180);
-      this.scene.add(gridHelper2);
-      const gridHelper3 = new GridHelper(128, 16);
-      gridHelper3.rotation.z = 90 * (Math.PI / 180);
-      this.scene.add(gridHelper3);
-    }
-    if (this.options.debug.axes) {
-      const axesHelper = new AxesHelper3(64);
-      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.resize(this.viewWidth, this.viewHeight);
-      };
-      window.addEventListener("resize", this._resizeListener);
-    }
-  }
-  get element() {
-    return this._element;
-  }
-  appendTo(element) {
-    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);
-  }
-  /**
-   * Register an EventDispatcher which may update the scene or renderer in order to redraw the scene
-   */
-  registerEventDispatcher(dispatcher, changeEvent2 = "change") {
-    dispatcher.addEventListener(changeEvent2, (event) => {
-      this._dirty = true;
-    });
-  }
-  resize(width, height) {
-    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);
-  }
-  //<editor-fold desc="RENDER">
-  get dirty() {
-    return this._dirty || this.scene.dirty;
-  }
-  set dirty(dirty) {
-    this._dirty = dirty;
-    this.scene.dirty = dirty;
-  }
-  start() {
-    stop();
-    this.renderer.setAnimationLoop(this._animationLoop);
-  }
-  stop() {
-    this.renderer.setAnimationLoop(null);
-    if (this._animationTimer)
-      clearTimeout(this._animationTimer);
-    this._animationTimer = void 0;
-    if (this._animationFrame)
-      cancelAnimationFrame(this._animationFrame);
-    this._animationFrame = void 0;
-  }
-  animate(t) {
-    if (this._stats) {
-      this._stats.begin();
-    }
-    if (this.dirty || this.options.render.renderAlways) {
-      if (this.options.composer.enabled) {
-        this.composer.render();
-      } else {
-        this.renderer.render(this.scene, this.camera);
-      }
-    }
-    this.dirty = false;
-    if (this._stats) {
-      this._stats.end();
-    }
-  }
-  //</editor-fold>
-  toImage() {
-    return this.renderer.domElement.toDataURL();
-  }
-  ///
-  get attachedToBody() {
-    return this.element === document.body;
-  }
-  get viewWidth() {
-    var _a;
-    return this.attachedToBody ? window.innerWidth : ((_a = this.element) == null ? void 0 : _a.offsetWidth) || 0;
-  }
-  get viewHeight() {
-    var _a;
-    return this.attachedToBody ? window.innerHeight : ((_a = this.element) == null ? void 0 : _a.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 Vector37(50, 50, 50),
-    lookingAt: new Vector37(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);
-    }
-    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);
-      }
-      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);
-    }
-    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);
-      }
-      return void 0;
-    });
-  }
-  static async capeFromCapesDev(uuid, capeType = "minecraft") {
-    return this.getCapesDev(uuid, capeType).then((cape) => {
-      if (cape) {
-        return cape == null ? void 0 : cape.stillImageUrl;
-      }
-      return void 0;
-    });
-  }
-  //</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"];
-      }
-      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"];
-      }
-      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;
-      }
-    });
-  }
-  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;
-  }
-  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
 import {
-  EventDispatcher as EventDispatcher2,
+  EventDispatcher,
   MOUSE,
   Quaternion as Quaternion3,
   Spherical,
   TOUCH,
   Vector2 as Vector23,
-  Vector3 as Vector38
+  Vector3 as Vector37
 } from "three";
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends EventDispatcher2 {
+var OrbitControls = class extends EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -5756,7 +5553,7 @@ var OrbitControls = class extends EventDispatcher2 {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new Vector38();
+    this.target = new Vector37();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -5808,10 +5605,10 @@ var OrbitControls = class extends EventDispatcher2 {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new Vector38();
-      const quat = new Quaternion3().setFromUnitVectors(object.up, new Vector38(0, 1, 0));
+      const offset = new Vector37();
+      const quat = new Quaternion3().setFromUnitVectors(object.up, new Vector37(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new Vector38();
+      const lastPosition = new Vector37();
       const lastQuaternion = new Quaternion3();
       const twoPI = 2 * Math.PI;
       return function update() {
@@ -5901,7 +5698,7 @@ var OrbitControls = class extends EventDispatcher2 {
     const spherical = new Spherical();
     const sphericalDelta = new Spherical();
     let scale = 1;
-    const panOffset = new Vector38();
+    const panOffset = new Vector37();
     let zoomChanged = false;
     const rotateStart = new Vector23();
     const rotateEnd = new Vector23();
@@ -5927,7 +5724,7 @@ var OrbitControls = class extends EventDispatcher2 {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new Vector38();
+      const v = new Vector37();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -5935,7 +5732,7 @@ var OrbitControls = class extends EventDispatcher2 {
       };
     }();
     const panUp = function() {
-      const v = new Vector38();
+      const v = new Vector37();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -5948,7 +5745,7 @@ var OrbitControls = class extends EventDispatcher2 {
       };
     }();
     const pan = function() {
-      const offset = new Vector38();
+      const offset = new Vector37();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -6384,6 +6181,489 @@ var MapControls = class extends OrbitControls {
   }
 };
 
+// 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 Stats();
+      document.body.appendChild(this._stats.dom);
+    }
+    this.init();
+    this._controls = this.createControls();
+  }
+  static {
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
+      camera: {
+        type: "perspective",
+        near: 1,
+        far: 5e3,
+        perspective: {
+          aspect: void 0,
+          fov: 50
+        },
+        orthographic: {
+          left: void 0,
+          right: void 0,
+          top: void 0,
+          bottom: void 0
+        },
+        position: new Vector38(50, 50, 50),
+        lookingAt: new Vector38(0, 0, 0)
+      },
+      render: {
+        fpsLimit: 60,
+        stats: false,
+        antialias: true,
+        shade: true,
+        autoResize: true,
+        renderAlways: false
+      },
+      composer: {
+        enabled: true
+      },
+      controls: {
+        enabled: false
+      },
+      debug: {
+        grid: false,
+        axes: false
+      }
+    });
+  }
+  //<editor-fold desc="INIT">
+  createScene() {
+    return new MineRenderScene();
+  }
+  createCamera() {
+    switch (this.options.camera.type) {
+      case "perspective":
+      default:
+        return new 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 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 WebGLRenderer({
+      antialias: this.options.render.antialias,
+      alpha: true,
+      powerPreference: "high-performance",
+      depth: true
+    });
+    renderer.setClearColor(0, 0);
+    renderer.shadowMap.enabled = true;
+    renderer.shadowMap.type = PCFSoftShadowMap;
+    renderer.outputColorSpace = SRGBColorSpace3;
+    renderer.setSize(this.viewWidth, this.viewHeight);
+    return renderer;
+  }
+  createComposer() {
+    if (!this.options.composer.enabled) return void 0;
+    const composer = new EffectComposer(this.renderer);
+    composer.setSize(this.viewWidth, this.viewHeight);
+    composer.addPass(new 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 }));
+    }
+    if (this.options.debug.grid) {
+      const gridHelper = new GridHelper(128, 16);
+      this._debugHelpers.push(gridHelper);
+      this.scene.add(gridHelper);
+      const gridHelper2 = new GridHelper(128, 16);
+      this._debugHelpers.push(gridHelper2);
+      gridHelper2.rotation.x = 90 * (Math.PI / 180);
+      this.scene.add(gridHelper2);
+      const gridHelper3 = new 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 AxesHelper3(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.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;
+    }
+    for (const [dispatcher, events] of this._eventDispatchers) {
+      for (const event of events) {
+        dispatcher.removeEventListener(event, this._changeListener);
+      }
+    }
+    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();
+    }
+    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();
+      }
+    }
+    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();
+    }
+    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;
+    }
+    if (this._stats) {
+      this._stats.begin();
+    }
+    if (this.options.composer.enabled && this.composer) {
+      this.composer.render();
+    } else {
+      this.renderer.render(this.scene, this.camera);
+    }
+    this.dirty = false;
+    if (this._stats) {
+      this._stats.end();
+    }
+  }
+  //</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;
+  }
+  ///
+};
+
+// 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);
+    }
+    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);
+      }
+      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);
+    }
+    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);
+      }
+      return void 0;
+    });
+  }
+  static async capeFromCapesDev(uuid, capeType = "minecraft") {
+    return this.getCapesDev(uuid, capeType).then((cape) => {
+      if (cape) {
+        return cape?.stillImageUrl;
+      }
+      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"];
+      }
+      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"];
+      }
+      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;
+      }
+    });
+  }
+  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;
+  }
+  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/world/Chunk.ts
 import { Box3 as Box32, Object3D as Object3D6, Vector3 as Vector310 } from "three";
 
@@ -6444,7 +6724,7 @@ var MineRenderWorld = class {
     console.log("CHUNKS", this._chunks);
     for (let chunk of this._chunks.values()) {
       console.log("dispose chunk", chunk);
-      await (chunk == null ? void 0 : chunk.dispose());
+      await chunk?.dispose();
     }
     this._chunks.clear();
   }
@@ -6498,7 +6778,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 = [];
@@ -6550,7 +6830,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];
     }
@@ -6616,6 +6896,7 @@ export {
   AXES,
   ArchiveAssetSource,
   AssetKey,
+  AssetLoadError,
   AssetLoader,
   AssetParser,
   AssetSource,
@@ -6673,6 +6954,7 @@ export {
   OrbitControls,
   PersistentCache,
   Renderer,
+  RequestError,
   Requests,
   SKIN_PARTS,
   SceneInspector,