@needle-tools/gltf-progressive 4.0.0-alpha.1 → 4.0.0-alpha.2

package/gltf-progressive.js

@@ -1,87 +1,99 @@
-import { RedFormat as Ue, RedIntegerFormat as ze, RGFormat as Ne, RGIntegerFormat as qe, RGBFormat as Ve, RGBAFormat as Ee, RGBAIntegerFormat as je, BufferGeometry as E, Mesh as j, Box3 as ge, Vector3 as A, Sphere as Ce, CompressedTexture as Xe, Texture as F, Matrix3 as Ke, InterleavedBuffer as Ye, InterleavedBufferAttribute as He, BufferAttribute as Qe, TextureLoader as Je, Matrix4 as Me, Timer as Ze, MeshStandardMaterial as et } from "three";
-import { GLTFLoader as _e } from "three/examples/jsm/loaders/GLTFLoader.js";
-import { MeshoptDecoder as tt } from "three/examples/jsm/libs/meshopt_decoder.module.js";
-import { DRACOLoader as st } from "three/examples/jsm/loaders/DRACOLoader.js";
-import { KTX2Loader as rt } from "three/examples/jsm/loaders/KTX2Loader.js";
-const ot = "";
-globalThis.GLTF_PROGRESSIVE_VERSION = ot;
+import * as Xe from "three";
+import { RedFormat as je, RedIntegerFormat as Ke, RGFormat as He, RGIntegerFormat as Ye, RGBFormat as Qe, RGBAFormat as Je, RGBAIntegerFormat as Ze, BufferGeometry as j, Mesh as K, Box3 as ue, Vector3 as k, Sphere as Ae, CompressedTexture as et, Texture as q, Matrix3 as tt, InterleavedBuffer as st, InterleavedBufferAttribute as rt, BufferAttribute as nt, TextureLoader as it, Color as Ie, Matrix4 as $e } from "three";
+import { GLTFLoader as De } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { MeshoptDecoder as ot } from "three/examples/jsm/libs/meshopt_decoder.module.js";
+import { DRACOLoader as at } from "three/examples/jsm/loaders/DRACOLoader.js";
+import { KTX2Loader as lt } from "three/examples/jsm/loaders/KTX2Loader.js";
+const ut = "";
+globalThis.GLTF_PROGRESSIVE_VERSION = ut;
 console.debug("[gltf-progressive] version -");
-let I = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", X = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
-const nt = I, it = X, Ae = new URL(I + "draco_decoder.js");
-Ae.searchParams.append("range", "true");
-fetch(Ae, {
+let $ = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/", H = "https://cdn.needle.tools/static/three/0.179.1/basis2/";
+const ct = $, ft = H, Be = new URL($ + "draco_decoder.js");
+Be.searchParams.append("range", "true");
+fetch(Be, {
   method: "GET",
   headers: {
     Range: "bytes=0-1"
   }
 }).catch((i) => {
-  console.debug(`Failed to fetch remote Draco decoder from ${I} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), I === nt && lt("./include/draco/"), X === it && ut("./include/ktx2/");
+  console.debug(`Failed to fetch remote Draco decoder from ${$} (offline: ${typeof navigator < "u" ? navigator.onLine : "unknown"})`), $ === ct && ht("./include/draco/"), H === ft && gt("./include/ktx2/");
 }).finally(() => {
-  ke();
+  qe();
 });
-const at = () => ({
-  dracoDecoderPath: I,
-  ktx2TranscoderPath: X
+const dt = () => ({
+  dracoDecoderPath: $,
+  ktx2TranscoderPath: H
 });
-function lt(i) {
-  I = i, C && C[pe] != I ? (console.debug("Updating Draco decoder path to " + i), C[pe] = I, C.setDecoderPath(I), C.preload()) : console.debug("Setting Draco decoder path to " + i);
+function ht(i) {
+  $ = i, C && C[ye] != $ ? (console.debug("Updating Draco decoder path to " + i), C[ye] = $, C.setDecoderPath($), C.preload()) : console.debug("Setting Draco decoder path to " + i);
 }
-function ut(i) {
-  X = i, $ && $.transcoderPath != X ? (console.debug("Updating KTX2 transcoder path to " + i), $.setTranscoderPath(X), $.init()) : console.debug("Setting KTX2 transcoder path to " + i);
+function gt(i) {
+  H = i, B && B.transcoderPath != H ? (console.debug("Updating KTX2 transcoder path to " + i), B.setTranscoderPath(H), B.init()) : console.debug("Setting KTX2 transcoder path to " + i);
 }
-function Le(i) {
-  return ke(), i ? $.detectSupport(i) : i !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: C, ktx2Loader: $, meshoptDecoder: ne };
+function _e(i) {
+  return qe(), i ? B.detectSupport(i) : i !== null && console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail"), { dracoLoader: C, ktx2Loader: B, meshoptDecoder: le };
 }
-function Re(i) {
-  i.dracoLoader || i.setDRACOLoader(C), i.ktx2Loader || i.setKTX2Loader($), i.meshoptDecoder || i.setMeshoptDecoder(ne);
+function Ge(i) {
+  i.dracoLoader || i.setDRACOLoader(C), i.ktx2Loader || i.setKTX2Loader(B), i.meshoptDecoder || i.setMeshoptDecoder(le);
 }
-const pe = /* @__PURE__ */ Symbol("dracoDecoderPath");
-let C, ne, $;
-function ke() {
-  C || (C = new st(), C[pe] = I, C.setDecoderPath(I), C.setDecoderConfig({ type: "js" }), C.preload()), $ || ($ = new rt(), $.setTranscoderPath(X), $.init()), ne || (ne = tt);
+const ye = /* @__PURE__ */ Symbol("dracoDecoderPath");
+let C, le, B;
+function qe() {
+  C || (C = new at(), C[ye] = $, C.setDecoderPath($), C.preload()), B || (B = new lt(), B.setTranscoderPath(H), B.init()), le || (le = ot);
 }
-const me = /* @__PURE__ */ new WeakMap();
-function Ie(i, t) {
-  let e = me.get(i);
-  e ? e = Object.assign(e, t) : e = t, me.set(i, e);
+const xe = /* @__PURE__ */ new WeakMap();
+function We(i, t) {
+  let e = xe.get(i);
+  e ? e = Object.assign(e, t) : e = t, xe.set(i, e);
 }
-const ct = _e.prototype.load;
-function dt(...i) {
-  const t = me.get(this);
+const pt = De.prototype.load;
+function mt(...i) {
+  const t = xe.get(this);
   let e = i[0];
-  const s = new URL(e, window.location.href);
-  if (s.hostname.endsWith("needle.tools")) {
-    const o = t?.progressive !== void 0 ? t.progressive : !0, n = t?.usecase ? t.usecase : "default";
-    o ? this.requestHeader.Accept = `*/*;progressive=allowed;usecase=${n}` : this.requestHeader.Accept = `*/*;usecase=${n}`, e = s.toString();
+  const s = yt(e);
+  if (s?.hostname.endsWith("needle.tools")) {
+    const n = t?.progressive !== void 0 ? t.progressive : !0, o = t?.usecase ? t.usecase : "default";
+    n ? this.requestHeader.Accept = `*/*;progressive=allowed;usecase=${o}` : this.requestHeader.Accept = `*/*;usecase=${o}`, e = s.toString();
+  }
+  return i[0] = e, pt?.call(this, ...i);
+}
+De.prototype.load = mt;
+function yt(i) {
+  try {
+    if (i instanceof URL)
+      return i;
+    const t = globalThis.location?.href;
+    return t ? new URL(i, t) : new URL(i);
+  } catch {
+    return null;
   }
-  return i[0] = e, ct?.call(this, ...i);
 }
-_e.prototype.load = dt;
-function De(i) {
+function Te(i) {
   return i != null && i.data != null;
 }
-function ye(i) {
+function we(i) {
   const t = i.source?.data;
   return t != null && typeof t == "object" ? t : null;
 }
-function ft(i) {
+function xt(i) {
   const t = i.image;
   return t != null && typeof t == "object" ? t : null;
 }
-function xe(i) {
-  const t = ft(i), e = ye(i);
+function Le(i) {
+  const t = xt(i), e = we(i);
   return {
     width: t?.width || e?.width || 0,
     height: t?.height || e?.height || 0
   };
 }
-N("debugprogressive");
-function N(i) {
-  if (typeof window > "u") return !1;
-  const e = new URL(window.location.href).searchParams.get(i);
-  return e == null || e === "0" || e === "false" ? !1 : e === "" ? !0 : e;
+V("debugprogressive");
+function V(i) {
+  const t = globalThis.location?.href;
+  if (!t) return !1;
+  const s = new URL(t).searchParams.get(i);
+  return s == null || s === "0" || s === "false" ? !1 : s === "" ? !0 : s;
 }
-function ht(i, t) {
+function wt(i, t) {
   if (t === void 0 || i === void 0 || t.startsWith("./") || t.startsWith("http") || t.startsWith("data:") || t.startsWith("blob:"))
     return t;
   const e = i.lastIndexOf("/");
@@ -92,18 +104,21 @@ function ht(i, t) {
   }
   return t;
 }
-function ve() {
-  return H !== void 0 || (H = /iPhone|iPad|iPod|Android|IEMobile/i.test(navigator.userAgent), N("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", H)), H;
+function Me() {
+  if (Z !== void 0) return Z;
+  const i = globalThis.navigator?.userAgent || "";
+  return Z = /iPhone|iPad|iPod|Android|IEMobile/i.test(i), V("debugprogressive") && console.log("[glTF Progressive]: isMobileDevice", Z), Z;
 }
-let H;
-function Oe() {
-  if (typeof window > "u") return !1;
-  const i = new URL(window.location.href), t = i.hostname === "localhost" || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(i.hostname);
-  return i.hostname === "127.0.0.1" || t;
+let Z;
+function Fe() {
+  const i = globalThis.location?.href;
+  if (!i) return !1;
+  const t = new URL(i), e = t.hostname === "localhost" || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(t.hostname);
+  return t.hostname === "127.0.0.1" || e;
 }
-class gt {
+class Lt {
   constructor(t, e = {}) {
-    this.maxConcurrent = t, this.debug = e.debug ?? !1, window.requestAnimationFrame(this.tick);
+    this.maxConcurrent = t, this.debug = e.debug ?? !1, typeof globalThis.requestAnimationFrame == "function" ? globalThis.requestAnimationFrame(this.tick) : setTimeout(this.tick, 0);
   }
   _running = /* @__PURE__ */ new Map();
   _queue = [];
@@ -130,85 +145,86 @@ class gt {
       this.debug && console.debug(`[PromiseQueue]: Running ${this._running.size} promises, waiting for ${this._queue.length} more.`);
       const { key: s, resolve: r } = this._queue.shift();
       r({
-        use: (o) => this.add(s, o)
+        use: (n) => this.add(s, n)
       });
     }
   }
 }
-function pt(i) {
-  const t = i.image, e = t?.width ?? 0, s = t?.height ?? 0, r = t?.depth ?? 1, o = Math.floor(Math.log2(Math.max(e, s, r))) + 1, n = mt(i);
-  return e * s * r * n * (1 - Math.pow(0.25, o)) / (1 - 0.25);
+function vt(i) {
+  const t = i.image, e = t?.width ?? 0, s = t?.height ?? 0, r = t?.depth ?? 1, n = Math.floor(Math.log2(Math.max(e, s, r))) + 1, o = Dt(i);
+  return e * s * r * o * (1 - Math.pow(0.25, n)) / (1 - 0.25);
 }
-function mt(i) {
+function Dt(i) {
   let t = 4;
   const e = i.format;
-  e === Ue || e === ze ? t = 1 : e === Ne || e === qe ? t = 2 : e === Ve || e === 1029 ? t = 3 : (e === Ee || e === je) && (t = 4);
+  e === je || e === Ke ? t = 1 : e === He || e === Ye ? t = 2 : e === Qe || e === 1029 ? t = 3 : (e === Je || e === Ze) && (t = 4);
   let s = 1;
   const r = i.type;
   return r === 1009 || r === 1010 ? s = 1 : r === 1011 || r === 1012 ? s = 2 : r === 1013 || r === 1014 || r === 1015 ? s = 4 : r === 1016 && (s = 2), t * s;
 }
-const yt = typeof window > "u" && typeof document > "u", we = /* @__PURE__ */ Symbol("needle:raycast-mesh");
-function ee(i) {
-  return i?.[we] instanceof E ? i[we] : null;
+const _t = typeof window > "u" && typeof document > "u", ve = /* @__PURE__ */ Symbol("needle:raycast-mesh");
+function ne(i) {
+  return i?.[ve] instanceof j ? i[ve] : null;
 }
-function xt(i, t) {
-  if ((i.type === "Mesh" || i.type === "SkinnedMesh") && !ee(i)) {
-    const s = _t(t);
-    s.userData = { isRaycastMesh: !0 }, i[we] = s;
+function Mt(i, t) {
+  if ((i.type === "Mesh" || i.type === "SkinnedMesh") && !ne(i)) {
+    const s = Tt(t);
+    s.userData = { isRaycastMesh: !0 }, i[ve] = s;
   }
 }
-function wt(i = !0) {
+function bt(i = !0) {
   if (i) {
-    if (Q) return;
-    const t = Q = j.prototype.raycast;
-    j.prototype.raycast = function(e, s) {
-      const r = this, o = ee(r);
-      let n;
-      o && r.isMesh && (n = r.geometry, r.geometry = o), t.call(this, e, s), n && (r.geometry = n);
+    if (ee) return;
+    const t = ee = K.prototype.raycast;
+    K.prototype.raycast = function(e, s) {
+      const r = this, n = ne(r);
+      let o;
+      n && r.isMesh && (o = r.geometry, r.geometry = n), t.call(this, e, s), o && (r.geometry = o);
     };
   } else {
-    if (!Q) return;
-    j.prototype.raycast = Q, Q = null;
+    if (!ee) return;
+    K.prototype.raycast = ee, ee = null;
   }
 }
-let Q = null;
-function _t(i) {
-  const t = new E();
+let ee = null;
+function Tt(i) {
+  const t = new j();
   for (const e in i.attributes)
     t.setAttribute(e, i.getAttribute(e));
   return t.setIndex(i.getIndex()), t;
 }
-const z = new Array(), f = N("debugprogressive");
-let Z, V = -1;
-if (f) {
+const F = new Array(), h = V("debugprogressive");
+let re, X = -1;
+if (h && typeof window < "u") {
   let i = function() {
-    V += 1, V >= t && (V = -1), console.log(`Toggle LOD level [${V}]`);
-  }, t = 6;
+    X += 1, X >= t && (X = -1), console.log(`Toggle LOD level [${X}]`);
+  };
+  const t = 6;
   window.addEventListener("keyup", (e) => {
-    e.key === "p" && i(), e.key === "w" && (Z = !Z, console.log(`Toggle wireframe [${Z}]`));
+    e.key === "p" && i(), e.key === "w" && (re = !re, console.log(`Toggle wireframe [${re}]`));
     const s = parseInt(e.key);
-    !isNaN(s) && s >= 0 && (V = s, console.log(`Set LOD level to [${V}]`));
+    !isNaN(s) && s >= 0 && (X = s, console.log(`Set LOD level to [${X}]`));
   });
 }
-function $e(i) {
-  if (f && Z !== void 0)
+function Ue(i) {
+  if (h && re !== void 0)
     if (Array.isArray(i))
       for (const t of i)
-        $e(t);
-    else i && "wireframe" in i && (i.wireframe = Z === !0);
+        Ue(t);
+    else i && "wireframe" in i && (i.wireframe = re === !0);
 }
-const J = new Array();
-let Lt = 0;
-const vt = ve() ? 2 : 10;
-function bt(i) {
-  if (J.length < vt) {
-    const s = J.length;
-    f && console.warn(`[Worker] Creating new worker #${s}`);
+const te = new Array();
+let Ot = 0;
+const St = Me() ? 2 : 10;
+function Rt(i) {
+  if (te.length < St) {
+    const s = te.length;
+    h && console.warn(`[Worker] Creating new worker #${s}`);
     const r = be.createWorker(i || {});
-    return J.push(r), r;
+    return te.push(r), r;
   }
-  const t = Lt++ % J.length;
-  return J[t];
+  const t = Ot++ % te.length;
+  return te[t];
 }
 class be {
   constructor(t, e) {
@@ -216,11 +232,11 @@ class be {
       const r = s.data;
       switch (this._debug && console.log("[Worker] EVENT", r), r.type) {
         case "loaded-gltf":
-          for (const o of this._running)
-            if (o.url === r.result.url) {
-              Mt(r.result), o.resolve(r.result);
-              const n = o.url;
-              n.startsWith("blob:") && URL.revokeObjectURL(n);
+          for (const n of this._running)
+            if (n.url === r.result.url) {
+              Pt(r.result), n.resolve(r.result);
+              const o = n.url;
+              o.startsWith("blob:") && URL.revokeObjectURL(o);
             }
       }
     }, t.onerror = (s) => {
@@ -242,22 +258,29 @@ class be {
   _running = [];
   _webglRenderer = null;
   async load(t, e) {
-    const s = at();
+    const s = dt();
     let r = e?.renderer;
     r || (this._webglRenderer ??= (async () => {
       const { WebGLRenderer: u } = await import("three");
       return new u();
     })(), r = await this._webglRenderer);
-    const l = Le(r).ktx2Loader.workerConfig;
-    t instanceof URL ? t = t.toString() : t.startsWith("file:") ? t = URL.createObjectURL(new Blob([t])) : !t.startsWith("blob:") && !t.startsWith("http:") && !t.startsWith("https:") && (t = new URL(t, window.location.href).toString());
-    const a = {
+    const a = _e(r).ktx2Loader.workerConfig;
+    if (t instanceof URL)
+      t = t.toString();
+    else if (t.startsWith("file:"))
+      t = URL.createObjectURL(new Blob([t]));
+    else if (!t.startsWith("blob:") && !t.startsWith("http:") && !t.startsWith("https:")) {
+      const u = globalThis.location?.href;
+      u && (t = new URL(t, u).toString());
+    }
+    const l = {
       type: "load",
       url: t,
       dracoDecoderPath: s.dracoDecoderPath,
       ktx2TranscoderPath: s.ktx2TranscoderPath,
-      ktx2LoaderConfig: l
+      ktx2LoaderConfig: a
     };
-    return this._debug && console.debug("[Worker] Sending load request", a), this.worker.postMessage(a), new Promise((u) => {
+    return this._debug && console.debug("[Worker] Sending load request", l), this.worker.postMessage(l), new Promise((u) => {
       this._running.push({
         url: t.toString(),
         resolve: u
@@ -266,32 +289,32 @@ class be {
   }
   _debug = !1;
 }
-function Mt(i) {
+function Pt(i) {
   for (const t of i.geometries) {
-    const e = t.geometry, s = new E();
+    const e = t.geometry, s = new j();
     if (s.name = e.name || "", e.index) {
       const r = e.index;
-      s.setIndex(le(r));
+      s.setIndex(fe(r));
     }
     for (const r in e.attributes) {
-      const o = e.attributes[r], n = le(o);
-      s.setAttribute(r, n);
+      const n = e.attributes[r], o = fe(n);
+      s.setAttribute(r, o);
     }
     if (e.morphAttributes)
       for (const r in e.morphAttributes) {
-        const n = e.morphAttributes[r].map((l) => le(l));
-        s.morphAttributes[r] = n;
+        const o = e.morphAttributes[r].map((a) => fe(a));
+        s.morphAttributes[r] = o;
       }
-    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new ge(), s.boundingBox.min = new A(
+    if (s.morphTargetsRelative = e.morphTargetsRelative ?? !1, s.boundingBox = new ue(), s.boundingBox.min = new k(
       e.boundingBox?.min.x,
       e.boundingBox?.min.y,
       e.boundingBox?.min.z
-    ), s.boundingBox.max = new A(
+    ), s.boundingBox.max = new k(
       e.boundingBox?.max.x,
       e.boundingBox?.max.y,
       e.boundingBox?.max.z
-    ), s.boundingSphere = new Ce(
-      new A(
+    ), s.boundingSphere = new Ae(
+      new k(
         e.boundingSphere?.center.x,
         e.boundingSphere?.center.y,
         e.boundingSphere?.center.z
@@ -306,11 +329,11 @@ function Mt(i) {
     const e = t.texture;
     let s = null;
     if (e.isCompressedTexture) {
-      const r = e.mipmaps, { width: o, height: n } = xe(e);
-      s = new Xe(
+      const r = e.mipmaps, { width: n, height: o } = Le(e);
+      s = new et(
         r,
-        o,
         n,
+        o,
         e.format,
         e.type,
         e.mapping,
@@ -322,7 +345,7 @@ function Mt(i) {
         e.colorSpace
       );
     } else
-      s = new F(
+      s = new q(
         e.image,
         e.mapping,
         e.wrapS,
@@ -333,7 +356,7 @@ function Mt(i) {
         e.type,
         e.anisotropy,
         e.colorSpace
-      ), s.mipmaps = e.mipmaps, s.channel = e.channel, s.source.data = e.source.data, s.flipY = e.flipY, s.premultiplyAlpha = e.premultiplyAlpha, s.unpackAlignment = e.unpackAlignment, s.matrix = new Ke(...e.matrix.elements);
+      ), s.mipmaps = e.mipmaps, s.channel = e.channel, s.source.data = e.source.data, s.flipY = e.flipY, s.premultiplyAlpha = e.premultiplyAlpha, s.unpackAlignment = e.unpackAlignment, s.matrix = new tt(...e.matrix.elements);
     if (!s) {
       console.error("[Worker] Failed to create new texture from received data. Texture is not a CompressedTexture or Texture.");
       continue;
@@ -342,66 +365,89 @@ function Mt(i) {
   }
   return i;
 }
-function le(i) {
+function fe(i) {
   let t = i;
   if ("isInterleavedBufferAttribute" in i && i.isInterleavedBufferAttribute) {
-    const e = i.data, s = e.array, r = new Ye(s, e.stride);
-    t = new He(r, i.itemSize, s.byteOffset, i.normalized), t.offset = i.offset;
-  } else "isBufferAttribute" in i && i.isBufferAttribute && (t = new Qe(i.array, i.itemSize, i.normalized), t.usage = i.usage, t.gpuType = i.gpuType, t.updateRanges = i.updateRanges);
+    const e = i.data, s = e.array, r = new st(s, e.stride);
+    t = new rt(r, i.itemSize, s.byteOffset, i.normalized), t.offset = i.offset;
+  } else "isBufferAttribute" in i && i.isBufferAttribute && (t = new nt(i.array, i.itemSize, i.normalized), t.usage = i.usage, t.gpuType = i.gpuType, t.updateRanges = i.updateRanges);
   return t;
 }
-const Dt = N("gltf-progressive-worker");
-N("gltf-progressive-reduce-mipmaps");
-const K = N("gltf-progressive-gc"), ue = /* @__PURE__ */ Symbol("needle-progressive-texture"), W = "NEEDLE_progressive";
-class m {
+const Ct = V("gltf-progressive-worker");
+V("gltf-progressive-reduce-mipmaps");
+const se = V("gltf-progressive-gc"), de = /* @__PURE__ */ Symbol("needle-progressive-texture"), U = "NEEDLE_progressive";
+class g {
   /** The name of the extension */
   get name() {
-    return W;
+    return U;
   }
   // #region PUBLIC API
+  /**
+   * Get the progressive mesh LOD extension data associated with a geometry.
+   * Returns the extension metadata (available LOD levels, vertex/index counts, densities) if the geometry was registered with progressive LODs, or `null` otherwise.
+   *
+   * @param geo - The buffer geometry to look up.
+   * @returns The mesh LOD extension data, or `null` if no progressive LODs are registered for this geometry.
+   */
   static getMeshLODExtension(t) {
     const e = this.getAssignedLODInformation(t);
     return e?.key ? this.lodInfos.get(e.key) : null;
   }
+  /**
+   * Get the glTF primitive index for a geometry within its parent mesh.
+   * A single glTF mesh node can contain multiple primitives (sub-geometries). This returns which primitive the geometry corresponds to.
+   *
+   * @param geo - The buffer geometry to look up.
+   * @returns The zero-based primitive index, or `-1` if no LOD information is assigned to this geometry.
+   */
   static getPrimitiveIndex(t) {
     const e = this.getAssignedLODInformation(t)?.index;
     return e ?? -1;
   }
+  /**
+   * Compute the minimum and maximum number of texture LOD levels across all textures of a material (or array of materials).
+   * Iterates over all texture slots on the material and collects LOD count ranges and per-level resolution bounds.
+   * Results are cached on the material so subsequent calls are free.
+   *
+   * @param material - A single material or an array of materials to inspect.
+   * @param minmax - Optional accumulator to merge results into (used internally for recursive calls with material arrays).
+   * @returns An object with `min_count` / `max_count` (the range of LOD levels across all textures) and a per-level `lods` array with `min_height` / `max_height`.
+   */
   static getMaterialMinMaxLODsCount(t, e) {
-    const s = this, r = "LODS:minmax", o = t[r];
-    if (o != null) return o;
+    const s = this, r = "LODS:minmax", n = t[r];
+    if (n != null) return n;
     if (e || (e = {
       min_count: 1 / 0,
       max_count: 0,
       lods: []
     }), Array.isArray(t)) {
-      for (const l of t)
-        this.getMaterialMinMaxLODsCount(l, e);
+      for (const a of t)
+        this.getMaterialMinMaxLODsCount(a, e);
       return t[r] = e, e;
     }
-    if (f === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
-      const l = t;
-      for (const a of Object.keys(l.uniforms)) {
-        const u = l.uniforms[a].value;
-        u?.isTexture === !0 && n(u, e);
+    if (h === "verbose" && console.log("getMaterialMinMaxLODsCount", t), t.type === "ShaderMaterial" || t.type === "RawShaderMaterial") {
+      const a = t;
+      for (const l of Object.keys(a.uniforms)) {
+        const u = a.uniforms[l].value;
+        u?.isTexture === !0 && o(u, e);
       }
     } else if (t.isMaterial)
-      for (const l of Object.keys(t)) {
-        const a = t[l];
-        a?.isTexture === !0 && n(a, e);
+      for (const a of Object.keys(t)) {
+        const l = t[a];
+        l?.isTexture === !0 && o(l, e);
       }
     else
-      f && console.warn(`[getMaterialMinMaxLODsCount] Unsupported material type: ${t.type}`);
+      h && console.warn(`[getMaterialMinMaxLODsCount] Unsupported material type: ${t.type}`);
     return t[r] = e, e;
-    function n(l, a) {
-      const u = s.getAssignedLODInformation(l);
+    function o(a, l) {
+      const u = s.getAssignedLODInformation(a);
       if (u) {
-        const c = s.lodInfos.get(u.key);
-        if (c && c.lods) {
-          a.min_count = Math.min(a.min_count, c.lods.length), a.max_count = Math.max(a.max_count, c.lods.length);
-          for (let y = 0; y < c.lods.length; y++) {
-            const w = c.lods[y];
-            w.width && (a.lods[y] = a.lods[y] || { min_height: 1 / 0, max_height: 0 }, a.lods[y].min_height = Math.min(a.lods[y].min_height, w.height), a.lods[y].max_height = Math.max(a.lods[y].max_height, w.height));
+        const f = s.lodInfos.get(u.key);
+        if (f && f.lods) {
+          l.min_count = Math.min(l.min_count, f.lods.length), l.max_count = Math.max(l.max_count, f.lods.length);
+          for (let c = 0; c < f.lods.length; c++) {
+            const d = f.lods[c];
+            d.width && (l.lods[c] = l.lods[c] || { min_height: 1 / 0, max_height: 0 }, l.lods[c].min_height = Math.min(l.lods[c].min_height, d.height), l.lods[c].max_height = Math.max(l.lods[c].max_height, d.height));
           }
         }
       }
@@ -414,26 +460,26 @@ class m {
    */
   static hasLODLevelAvailable(t, e) {
     if (Array.isArray(t)) {
-      for (const o of t)
-        if (this.hasLODLevelAvailable(o, e)) return !0;
+      for (const n of t)
+        if (this.hasLODLevelAvailable(n, e)) return !0;
       return !1;
     }
     if (t.isMaterial === !0) {
-      for (const o of Object.keys(t)) {
-        const n = t[o];
-        if (n && n.isTexture && this.hasLODLevelAvailable(n, e))
+      for (const n of Object.keys(t)) {
+        const o = t[n];
+        if (o && o.isTexture && this.hasLODLevelAvailable(o, e))
           return !0;
       }
       return !1;
     } else if (t.isGroup === !0) {
-      for (const o of t.children)
-        if (o.isMesh === !0 && this.hasLODLevelAvailable(o, e))
+      for (const n of t.children)
+        if (n.isMesh === !0 && this.hasLODLevelAvailable(n, e))
           return !0;
     }
     let s, r;
     if (t.isMesh ? s = t.geometry : (t.isBufferGeometry || t.isTexture) && (s = t), s && s?.userData?.LODS) {
-      const o = s.userData.LODS;
-      if (r = this.lodInfos.get(o.key), e === void 0) return r != null;
+      const n = s.userData.LODS;
+      if (r = this.lodInfos.get(n.key), e === void 0) return r != null;
       if (r)
         return Array.isArray(r.lods) ? e < r.lods.length : e === 0;
     }
@@ -453,74 +499,80 @@ class m {
    * });
    * ```
    */
-  static assignMeshLOD(t, e) {
+  static assignMeshLOD(t, e, s) {
     if (!t) return Promise.resolve(null);
-    if (t instanceof j || t.isMesh === !0) {
-      const s = t.geometry, r = this.getAssignedLODInformation(s);
-      if (!r)
+    if (t instanceof K || t.isMesh === !0) {
+      const r = t.geometry, n = this.getAssignedLODInformation(r);
+      if (!n)
         return Promise.resolve(null);
-      for (const o of z)
-        o.onBeforeGetLODMesh?.(t, e);
-      return t["LOD:requested level"] = e, m.getOrLoadLOD(s, e).then((o) => {
-        if (Array.isArray(o)) {
-          const n = r.index || 0;
-          o = o[n];
+      for (const a of F)
+        a.onBeforeGetLODMesh?.(t, e);
+      t["LOD:requested level"] = e;
+      const o = () => t["LOD:requested level"] === e || this.shouldApplyStaleMeshLOD(t, e);
+      return g.getOrLoadLOD(r, e, {
+        isCurrent: o
+      }).then((a) => {
+        if (Array.isArray(a)) {
+          const u = n.index || 0;
+          a = a[u];
         }
-        return t["LOD:requested level"] === e && (delete t["LOD:requested level"], o && s != o && (o?.isBufferGeometry ? t.geometry = o : f && console.error("Invalid LOD geometry", o))), o;
-      }).catch((o) => (console.error("Error loading mesh LOD", t, o), null));
-    } else f && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", t);
+        const l = t["LOD:requested level"] === e;
+        return (l || this.shouldApplyStaleMeshLOD(t, e)) && (l && delete t["LOD:requested level"], a && r != a && (a?.isBufferGeometry ? typeof s?.apply == "function" ? s.apply(a, e, t) : s?.apply !== !1 && (t.geometry = a) : h && console.error("Invalid LOD geometry", a))), a;
+      }).catch((a) => (console.error("Error loading mesh LOD", t, a), null));
+    } else h && console.error("Invalid call to assignMeshLOD: Request mesh LOD but the object is not a mesh", t);
     return Promise.resolve(null);
   }
-  static assignTextureLOD(t, e = 0) {
+  static assignTextureLOD(t, e = 0, s) {
     if (!t) return Promise.resolve(null);
+    const r = s?.force === !0;
     if (t.isMesh === !0) {
-      const s = t;
-      if (Array.isArray(s.material)) {
-        const r = new Array();
-        for (const o of s.material) {
-          const n = this.assignTextureLOD(o, e);
-          r.push(n);
+      const n = t;
+      if (Array.isArray(n.material)) {
+        const o = new Array();
+        for (const a of n.material) {
+          const l = this.assignTextureLOD(a, e, s);
+          o.push(l);
         }
-        return Promise.all(r).then((o) => {
-          const n = new Array();
-          for (const l of o)
-            Array.isArray(l) && n.push(...l);
-          return n;
+        return Promise.all(o).then((a) => {
+          const l = new Array();
+          for (const u of a)
+            Array.isArray(u) && l.push(...u);
+          return l;
         });
       } else
-        return this.assignTextureLOD(s.material, e);
+        return this.assignTextureLOD(n.material, e, s);
     }
     if (t.isMaterial === !0) {
-      const s = t, r = [], o = new Array();
-      if (s.uniforms && (s.isRawShaderMaterial || s.isShaderMaterial === !0)) {
-        const n = s;
-        for (const l of Object.keys(n.uniforms)) {
-          const a = n.uniforms[l].value;
-          if (a?.isTexture === !0) {
-            const u = this.assignTextureLODForSlot(a, e, s, l).then((c) => (c && n.uniforms[l].value != c && (n.uniforms[l].value = c, n.uniformsNeedUpdate = !0), c));
-            r.push(u), o.push(l);
+      const n = t, o = [], a = new Array();
+      if (this.trackCurrentMaterialTextureSlots(n), n.uniforms && (n.isRawShaderMaterial || n.isShaderMaterial === !0)) {
+        const l = n;
+        for (const u of Object.keys(l.uniforms)) {
+          const f = l.uniforms[u].value;
+          if (f?.isTexture === !0) {
+            const c = this.assignTextureLODForSlot(f, e, n, u, r).then((d) => (d && l.uniforms[u].value != d && (l.uniforms[u].value = d, l.uniformsNeedUpdate = !0), d));
+            o.push(c), a.push(u);
           }
         }
       } else
-        for (const n of Object.keys(s)) {
-          const l = s[n];
-          if (l?.isTexture === !0) {
-            const a = this.assignTextureLODForSlot(l, e, s, n);
-            r.push(a), o.push(n);
+        for (const l of Object.keys(n)) {
+          const u = n[l];
+          if (u?.isTexture === !0) {
+            const f = this.assignTextureLODForSlot(u, e, n, l, r);
+            o.push(f), a.push(l);
           }
         }
-      return Promise.all(r).then((n) => {
-        const l = new Array();
-        for (let a = 0; a < n.length; a++) {
-          const u = n[a], c = o[a];
-          u && u.isTexture === !0 ? l.push({ material: s, slot: c, texture: u, level: e }) : l.push({ material: s, slot: c, texture: null, level: e });
+      return Promise.all(o).then((l) => {
+        const u = new Array();
+        for (let f = 0; f < l.length; f++) {
+          const c = l[f], d = a[f];
+          c && c.isTexture === !0 ? u.push({ material: n, slot: d, texture: c, level: e }) : u.push({ material: n, slot: d, texture: null, level: e });
         }
-        return l;
+        return u;
       });
     }
-    if (t instanceof F || t.isTexture === !0) {
-      const s = t;
-      return this.assignTextureLODForSlot(s, e, null, null);
+    if (t instanceof q || t.isTexture === !0) {
+      const n = t;
+      return this.assignTextureLODForSlot(n, e, null, null, r);
     }
     return Promise.resolve(null);
   }
@@ -529,46 +581,144 @@ class m {
    * @default 50 on desktop, 20 on mobile devices
    */
   static set maxConcurrentLoadingTasks(t) {
-    m.queue.maxConcurrent = t;
+    g.queue.maxConcurrent = t;
   }
   static get maxConcurrentLoadingTasks() {
-    return m.queue.maxConcurrent;
+    return g.queue.maxConcurrent;
   }
   // #region INTERNAL
-  static assignTextureLODForSlot(t, e, s, r) {
-    return t?.isTexture !== !0 ? Promise.resolve(null) : r === "glyphMap" ? Promise.resolve(t) : m.getOrLoadLOD(t, e).then((o) => {
-      if (Array.isArray(o))
+  static assignTextureLODForSlot(t, e, s, r, n) {
+    if (t?.isTexture !== !0)
+      return Promise.resolve(null);
+    if (r === "glyphMap")
+      return Promise.resolve(t);
+    const o = this.getAssignedLODInformation(t);
+    if (o && (o.level === e || !n && o.level < e))
+      return Promise.resolve(t);
+    if (s && r) {
+      const c = this.getPendingTextureSlotRequest(s, r);
+      if (c && c.level === e && c.force === n)
+        return c.promise;
+    }
+    const a = s && r ? this.nextTextureSlotRequestId(s, r, e, n) : 0, l = () => !s || !r || this.getLatestTextureSlotRequest(s, r)?.id === a, u = () => l() || this.shouldApplyStaleTextureSlotLOD(s, r, e, n), f = g.getOrLoadLOD(t, e, {
+      isCurrent: u
+    }).then((c) => {
+      if (!l() && !this.shouldApplyStaleTextureSlotLOD(s, r, e, n)) return null;
+      if (Array.isArray(c))
         return console.warn("Progressive: Got an array of textures for a texture slot, this should not happen..."), null;
-      if (o?.isTexture === !0) {
-        if (o != t && s && r) {
-          const n = s[r];
-          if (n && !f) {
-            const l = this.getAssignedLODInformation(n);
-            if (l && l?.level < e)
-              return f === "verbose" && console.warn("Assigned texture level is already higher: ", l.level, e, s, n, o), o && o !== n && ((f || K) && console.log(`[gltf-progressive] Disposing rejected lower-quality texture LOD ${e} (assigned is ${l.level})`, o.uuid), o.dispose()), null;
+      if (c?.isTexture === !0) {
+        if (c != t && s && r) {
+          const d = this.getMaterialTextureSlot(s, r) ?? t;
+          if (d && !n) {
+            const p = this.getAssignedLODInformation(d);
+            if (p && p?.level < e)
+              return h === "verbose" && console.warn("Assigned texture level is already higher: ", p.level, e, s, d, c), null;
           }
-          if (this.trackTextureUsage(o), n && n !== o && this.untrackTextureUsage(n) && (f || K)) {
-            const a = this.getAssignedLODInformation(n);
-            console.log(`[gltf-progressive] Disposed old texture LOD ${a?.level ?? "?"} → ${e} for ${s.name || s.type}.${r}`, n.uuid);
-          }
-          s[r] = o;
+          this.assignTrackedTextureSlot(s, r, c);
         }
-        return o;
-      } else f == "verbose" && console.warn("No LOD found for", t, e);
+        return c;
+      } else h == "verbose" && console.warn("No LOD found for", t, e);
       return null;
-    }).catch((o) => (console.error("Error loading LOD", t, o), null));
+    }).catch((c) => (console.error("Error loading LOD", t, c), null));
+    return s && r && this.setPendingTextureSlotRequest(s, r, e, n, a, f), f;
+  }
+  // Track material slots, not just texture objects. A shared fallback texture can be
+  // referenced by many slots and should only be disposed after every slot moved away.
+  static trackedTextureSlots = /* @__PURE__ */ new WeakMap();
+  static pendingTextureSlotRequests = /* @__PURE__ */ new WeakMap();
+  static latestTextureSlotRequests = /* @__PURE__ */ new WeakMap();
+  static textureSlotRequestId = 0;
+  static trackCurrentMaterialTextureSlots(t) {
+    if (t.uniforms && (t.isRawShaderMaterial || t.isShaderMaterial === !0)) {
+      const e = t;
+      for (const s of Object.keys(e.uniforms)) {
+        const r = e.uniforms[s].value;
+        r?.isTexture === !0 && this.ensureTrackedTextureSlot(t, s, r);
+      }
+      return;
+    }
+    for (const e of Object.keys(t)) {
+      const s = t[e];
+      s?.isTexture === !0 && this.ensureTrackedTextureSlot(t, e, s);
+    }
+  }
+  static getPendingTextureSlotRequest(t, e) {
+    return this.pendingTextureSlotRequests.get(t)?.get(e);
+  }
+  static nextTextureSlotRequestId(t, e, s, r) {
+    let n = this.latestTextureSlotRequests.get(t);
+    n || (n = /* @__PURE__ */ new Map(), this.latestTextureSlotRequests.set(t, n));
+    const o = ++this.textureSlotRequestId;
+    return n.set(e, { id: o, level: s, force: r }), o;
+  }
+  static getLatestTextureSlotRequest(t, e) {
+    return this.latestTextureSlotRequests.get(t)?.get(e);
+  }
+  static shouldApplyStaleTextureSlotLOD(t, e, s, r) {
+    if (!t || !e) return !1;
+    const n = this.getLatestTextureSlotRequest(t, e), o = this.getMaterialTextureSlot(t, e), a = this.getAssignedLODInformation(o)?.level ?? 1 / 0;
+    return s >= a ? !1 : r ? n ? s >= n.level : !1 : !0;
+  }
+  static shouldApplyStaleMeshLOD(t, e) {
+    const s = t["LOD:requested level"];
+    if (typeof s != "number") return !1;
+    const r = this.getAssignedLODInformation(t.geometry)?.level ?? 1 / 0;
+    return e < r && e >= s;
+  }
+  static setPendingTextureSlotRequest(t, e, s, r, n, o) {
+    let a = this.pendingTextureSlotRequests.get(t);
+    a || (a = /* @__PURE__ */ new Map(), this.pendingTextureSlotRequests.set(t, a));
+    const l = { level: s, force: r, id: n, promise: o };
+    a.set(e, l), o.finally(() => {
+      a.get(e)?.id === n && a.delete(e);
+    });
+  }
+  static getMaterialTextureSlot(t, e) {
+    const r = t.uniforms?.[e];
+    if (r?.value?.isTexture === !0)
+      return r.value;
+    const n = t[e];
+    return n?.isTexture === !0 ? n : null;
+  }
+  static setMaterialTextureSlot(t, e, s) {
+    const n = t.uniforms?.[e];
+    if (n?.value?.isTexture === !0) {
+      n.value = s, t.uniformsNeedUpdate = !0;
+      return;
+    }
+    t[e] = s;
+  }
+  static assignTrackedTextureSlot(t, e, s) {
+    let r = this.trackedTextureSlots.get(t);
+    r || (r = /* @__PURE__ */ new Map(), this.trackedTextureSlots.set(t, r));
+    const n = this.getMaterialTextureSlot(t, e);
+    let o = r.get(e);
+    !o && n ? o = this.ensureTrackedTextureSlot(t, e, n) : o && n && o !== n && (this.releaseTrackedTextureSlot(t, e, o), o = this.ensureTrackedTextureSlot(t, e, n)), !(o === s && n === s) && (o && o !== s && this.releaseTrackedTextureSlot(t, e, o), o !== s && (this.trackTextureUsage(s), r.set(e, s)), n !== s && this.setMaterialTextureSlot(t, e, s));
+  }
+  static ensureTrackedTextureSlot(t, e, s) {
+    let r = this.trackedTextureSlots.get(t);
+    r || (r = /* @__PURE__ */ new Map(), this.trackedTextureSlots.set(t, r));
+    const n = r.get(e);
+    return n === s ? n : (n && this.releaseTrackedTextureSlot(t, e, n), this.trackTextureUsage(s), r.set(e, s), s);
+  }
+  static releaseTrackedTextureSlot(t, e, s) {
+    const r = this.trackedTextureSlots.get(t);
+    if (r?.get(e) === s && r.delete(e), this.untrackTextureUsage(s) && (h || se)) {
+      const o = this.getAssignedLODInformation(s);
+      console.log(`[gltf-progressive] Disposed old texture LOD ${o?.level ?? "?"} for ${t.name || t.type}.${e}`, s.uuid);
+    }
   }
   parser;
   url;
   constructor(t) {
     const e = t.options.path;
-    f && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
+    h && console.log("Progressive extension registered for", e), this.parser = t, this.url = e;
   }
   _isLoadingMesh;
   loadMesh = (t) => {
     if (this._isLoadingMesh) return null;
-    const e = this.parser.json.meshes[t]?.extensions?.[W];
-    return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((s) => (this._isLoadingMesh = !1, s && m.registerMesh(this.url, e.guid, s, e.lods?.length, 0, e), s))) : null;
+    const e = this.parser.json.meshes[t]?.extensions?.[U];
+    return e ? (this._isLoadingMesh = !0, this.parser.getDependency("mesh", t).then((s) => (this._isLoadingMesh = !1, s && g.registerMesh(this.url, e.guid, s, e.lods?.length, 0, e), s))) : null;
   };
   // private _isLoadingTexture;
   // loadTexture = (textureIndex: number) => {
@@ -585,65 +735,83 @@ class m {
   //     });
   // }
   afterRoot(t) {
-    return f && console.log("AFTER", this.url, t), this.parser.json.textures?.forEach((e, s) => {
+    return h && console.log("AFTER", this.url, t), this.parser.json.textures?.forEach((e, s) => {
       if (e?.extensions) {
-        const r = e?.extensions[W];
+        const r = e?.extensions[U];
         if (r) {
           if (!r.lods) {
-            f && console.warn("Texture has no LODs", r);
+            h && console.warn("Texture has no LODs", r);
             return;
           }
-          let o = !1;
-          for (const n of this.parser.associations.keys())
-            n.isTexture === !0 && this.parser.associations.get(n)?.textures === s && (o = !0, m.registerTexture(this.url, n, r.lods?.length, s, r));
-          o || this.parser.getDependency("texture", s).then((n) => {
-            n && m.registerTexture(this.url, n, r.lods?.length, s, r);
+          let n = !1;
+          for (const o of this.parser.associations.keys())
+            o.isTexture === !0 && this.parser.associations.get(o)?.textures === s && (n = !0, g.registerTexture(this.url, o, r.lods?.length, s, r));
+          n || this.parser.getDependency("texture", s).then((o) => {
+            o && g.registerTexture(this.url, o, r.lods?.length, s, r);
           });
         }
       }
     }), this.parser.json.meshes?.forEach((e, s) => {
       if (e?.extensions) {
-        const r = e?.extensions[W];
+        const r = e?.extensions[U];
         if (r && r.lods) {
-          for (const o of this.parser.associations.keys())
-            if (o.isMesh) {
-              const n = this.parser.associations.get(o);
-              n?.meshes === s && m.registerMesh(this.url, r.guid, o, r.lods.length, n.primitives, r);
+          for (const n of this.parser.associations.keys())
+            if (n.isMesh) {
+              const o = this.parser.associations.get(n);
+              o?.meshes === s && g.registerMesh(this.url, r.guid, n, r.lods.length, o.primitives, r);
             }
         }
       }
     }), null;
   }
   /**
-   * Register a texture with LOD information
+   * Register a texture with progressive LOD information. This associates the texture with its LOD extension data
+   * so the LODs manager can later swap it for higher or lower resolution versions based on screen coverage.
+   * Typically called during glTF loading when the progressive extension is parsed.
+   *
+   * @param url - The source URL of the glTF file this texture was loaded from.
+   * @param tex - The three.js Texture instance to register.
+   * @param level - The LOD level this texture represents (0 = highest resolution).
+   * @param index - The texture index within the glTF file.
+   * @param ext - The parsed progressive texture extension data containing all available LOD levels and their dimensions.
    */
-  static registerTexture = (t, e, s, r, o) => {
+  static registerTexture = (t, e, s, r, n) => {
     if (!e) {
-      f && console.error("!! gltf-progressive: Called register texture without texture");
+      h && console.error("!! gltf-progressive: Called register texture without texture");
       return;
     }
-    if (f) {
-      const { width: l, height: a } = xe(e);
-      console.log(`> gltf-progressive: register texture[${r}] "${e.name || e.uuid}", Current: ${l}x${a}, Max: ${o.lods[0]?.width}x${o.lods[0]?.height}, uuid: ${e.uuid}`, o, e);
+    if (h) {
+      const { width: a, height: l } = Le(e);
+      console.log(`> gltf-progressive: register texture[${r}] "${e.name || e.uuid}", Current: ${a}x${l}, Max: ${n.lods[0]?.width}x${n.lods[0]?.height}, uuid: ${e.uuid}`, n, e);
     }
-    e.source && (e.source[ue] = o);
-    const n = o.guid;
-    m.assignLODInformation(t, e, n, s, r), m.lodInfos.set(n, o), m.lowresCache.set(n, new WeakRef(e));
+    e.source && (e.source[de] = n);
+    const o = n.guid;
+    g.assignLODInformation(t, e, o, s, r), g.lodInfos.set(o, n), g.lowresCache.set(o, new WeakRef(e));
   };
   /**
-   * Register a mesh with LOD information
+   * Register a mesh with progressive LOD information. This associates the mesh geometry with its LOD extension data
+   * so the LODs manager can later swap it for higher or lower density versions based on screen coverage.
+   * Typically called during glTF loading when the progressive extension is parsed.
+   * If the mesh is registered at a level > 0 (i.e. not full resolution), a raycast mesh is automatically preserved for accurate picking.
+   *
+   * @param url - The source URL of the glTF file this mesh was loaded from.
+   * @param key - A unique key identifying this mesh's LOD group (typically derived from the extension GUID).
+   * @param mesh - The three.js Mesh instance to register.
+   * @param level - The LOD level this mesh represents (0 = highest resolution / full density).
+   * @param index - The primitive index within the glTF mesh node.
+   * @param ext - The parsed progressive mesh extension data containing all available LOD levels with vertex/index counts and densities.
    */
-  static registerMesh = (t, e, s, r, o, n) => {
-    const l = s.geometry;
-    if (!l) {
-      f && console.warn("gltf-progressive: Register mesh without geometry");
+  static registerMesh = (t, e, s, r, n, o) => {
+    const a = s.geometry;
+    if (!a) {
+      h && console.warn("gltf-progressive: Register mesh without geometry");
       return;
     }
-    l.userData || (l.userData = {}), f && console.log("> Progressive: register mesh " + s.name, { index: o, uuid: s.uuid }, n, s), m.assignLODInformation(t, l, e, r, o), m.lodInfos.set(e, n);
-    let u = m.lowresCache.get(e)?.deref();
-    u ? u.push(s.geometry) : u = [s.geometry], m.lowresCache.set(e, new WeakRef(u)), r > 0 && !ee(s) && xt(s, l);
-    for (const c of z)
-      c.onRegisteredNewMesh?.(s, n);
+    a.userData || (a.userData = {}), h && console.log("> Progressive: register mesh " + s.name, { index: n, uuid: s.uuid }, o, s), g.assignLODInformation(t, a, e, r, n), g.lodInfos.set(e, o);
+    let u = g.lowresCache.get(e)?.deref();
+    u ? u.push(s.geometry) : u = [s.geometry], g.lowresCache.set(e, new WeakRef(u)), r > 0 && !ne(s) && Mt(s, a);
+    for (const f of F)
+      f.onRegisteredNewMesh?.(s, o);
   };
   /**
    * Dispose cached resources to free memory.
@@ -684,7 +852,7 @@ class m {
       this.lowresCache.clear();
       for (const [, e] of this.cache)
         this._disposeCacheEntry(e);
-      this.cache.clear(), this.textureRefCounts.clear();
+      this.cache.clear(), this.textureRefCounts.clear(), this.trackedTextureSlots = /* @__PURE__ */ new WeakMap(), this.pendingTextureSlotRequests = /* @__PURE__ */ new WeakMap(), this.latestTextureSlotRequests = /* @__PURE__ */ new WeakMap(), this.textureSlotRequestId = 0;
     }
   }
   /** Dispose a single cache entry's three.js resource(s) to free GPU memory. */
@@ -716,16 +884,16 @@ class m {
    * The held value is the cache key string used in `previouslyLoaded`.
    */
   static _resourceRegistry = new FinalizationRegistry((t) => {
-    const e = m.cache.get(t);
-    (f || K) && console.debug(`[gltf-progressive] Memory: Resource GC'd
-${t}`), e instanceof WeakRef && (e.deref() || (m.cache.delete(t), (f || K) && console.log("[gltf-progressive] ↪ Cache entry deleted (GC)")));
+    const e = g.cache.get(t);
+    (h || se) && console.debug(`[gltf-progressive] Memory: Resource GC'd
+${t}`), e instanceof WeakRef && (e.deref() || (g.cache.delete(t), (h || se) && console.log("[gltf-progressive] ↪ Cache entry deleted (GC)")));
   });
   /**
    * Track texture usage by incrementing reference count
    */
   static trackTextureUsage(t) {
     const e = t.uuid, s = this.textureRefCounts.get(e) || 0;
-    this.textureRefCounts.set(e, s + 1), f === "verbose" && console.log(`[gltf-progressive] Track texture ${e}, refCount: ${s} → ${s + 1}`);
+    this.textureRefCounts.set(e, s + 1), h === "verbose" && console.log(`[gltf-progressive] Track texture ${e}, refCount: ${s} → ${s + 1}`);
   }
   /**
    * Untrack texture usage by decrementing reference count.
@@ -735,182 +903,196 @@ ${t}`), e instanceof WeakRef && (e.deref() || (m.cache.delete(t), (f || K) && co
   static untrackTextureUsage(t) {
     const e = t.uuid, s = this.textureRefCounts.get(e);
     if (!s)
-      return (f === "verbose" || K) && o("[gltf-progressive] Memory: Untrack untracked texture (dispose immediately)", 0), t.dispose(), !0;
+      return (h === "verbose" || se) && n("[gltf-progressive] Memory: Untrack untracked texture (dispose immediately)", 0), t.dispose(), !0;
     const r = s - 1;
     if (r <= 0)
-      return this.textureRefCounts.delete(e), (f || K) && o("[gltf-progressive] Memory: Dispose texture", r), t.dispose(), !0;
-    return this.textureRefCounts.set(e, r), f === "verbose" && o("[gltf-progressive] Memory: Untrack texture", r), !1;
-    function o(n, l) {
-      let { width: a, height: u } = xe(t);
-      const c = a && u ? `${a}x${u}` : "N/A";
-      let y = "N/A";
-      a && u && (y = `~${(pt(t) / (1024 * 1024)).toFixed(2)} MB`), console.log(`${n} — ${t.name} ${c} (${y}), refCount: ${s} → ${l}
+      return this.textureRefCounts.delete(e), (h || se) && n("[gltf-progressive] Memory: Dispose texture", r), t.dispose(), !0;
+    return this.textureRefCounts.set(e, r), h === "verbose" && n("[gltf-progressive] Memory: Untrack texture", r), !1;
+    function n(o, a) {
+      let { width: l, height: u } = Le(t);
+      const f = l && u ? `${l}x${u}` : "N/A";
+      let c = "N/A";
+      l && u && (c = `~${(vt(t) / (1024 * 1024)).toFixed(2)} MB`), console.log(`${o} — ${t.name} ${f} (${c}), refCount: ${s} → ${a}
 ${e}`);
     }
   }
   static workers = [];
   static _workersIndex = 0;
-  static async getOrLoadLOD(t, e) {
-    const s = f == "verbose", r = this.getAssignedLODInformation(t);
-    if (!r)
-      return f && console.warn(`[gltf-progressive] No LOD information found: ${t.name}, uuid: ${t.uuid}, type: ${t.type}`, t), null;
-    const o = r?.key;
-    let n;
+  static async getOrLoadLOD(t, e, s) {
+    const r = h == "verbose", n = this.getAssignedLODInformation(t);
+    if (!n)
+      return h && console.warn(`[gltf-progressive] No LOD information found: ${t.name}, uuid: ${t.uuid}, type: ${t.type}`, t), null;
+    const o = n?.key;
+    let a;
     if (t.isTexture === !0) {
-      const a = t;
-      a.source && a.source[ue] && (n = a.source[ue]);
+      const u = t;
+      u.source && u.source[de] && (a = u.source[de]);
     }
-    if (n || (n = m.lodInfos.get(o)), !n)
-      f && console.warn(`Can not load LOD ${e}: no LOD info found for "${o}" ${t.name}`, t.type, m.lodInfos);
+    if (a || (a = g.lodInfos.get(o)), !a)
+      h && console.warn(`Can not load LOD ${e}: no LOD info found for "${o}" ${t.name}`, t.type, g.lodInfos);
     else {
       if (e > 0) {
         let c = !1;
-        const y = Array.isArray(n.lods);
-        if (y && e >= n.lods.length ? c = !0 : y || (c = !0), c) {
-          const w = this.lowresCache.get(o);
-          if (w) {
-            const _ = w.deref();
-            if (_) return _;
-            this.lowresCache.delete(o), f && console.log(`[gltf-progressive] Lowres cache entry was GC'd: ${o}`);
+        const d = Array.isArray(a.lods);
+        if (d && e >= a.lods.length ? c = !0 : d || (c = !0), c) {
+          const p = this.lowresCache.get(o);
+          if (p) {
+            const b = p.deref();
+            if (b) return b;
+            this.lowresCache.delete(o), h && console.log(`[gltf-progressive] Lowres cache entry was GC'd: ${o}`);
           }
           return null;
         }
       }
-      const a = Array.isArray(n.lods) ? n.lods[e]?.path : n.lods;
-      if (!a)
-        return f && !n["missing:uri"] && (n["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, n)), null;
-      const u = ht(r.url, a);
-      if (u.endsWith(".glb") || u.endsWith(".gltf")) {
-        if (!n.guid)
-          return console.warn("missing pointer for glb/gltf texture", n), null;
-        const c = u + "_" + n.guid, y = await this.queue.slot(u), w = this.cache.get(c);
-        if (w !== void 0)
-          if (s && console.log(`LOD ${e} was already loading/loaded: ${c}`), w instanceof WeakRef) {
-            const d = w.deref();
-            if (d) {
-              let g = d, b = !1;
-              if (g instanceof F && t instanceof F ? De(g.image) || ye(g) ? g = this.copySettings(t, g) : b = !0 : g instanceof E && t instanceof E && (g.attributes.position?.array || (b = !0)), !b)
-                return g;
-            }
-            this.cache.delete(c), f && console.log(`[gltf-progressive] Re-loading GC'd/disposed resource: ${c}`);
-          } else {
-            let d = await w.catch((b) => (console.error(`Error loading LOD ${e} from ${u}
-`, b), null)), g = !1;
-            if (d == null || (d instanceof F && t instanceof F ? De(d.image) || ye(d) ? d = this.copySettings(t, d) : (g = !0, this.cache.delete(c)) : d instanceof E && t instanceof E && (d.attributes.position?.array || (g = !0, this.cache.delete(c)))), !g)
-              return d;
-          }
-        if (!y.use)
-          return f && console.log(`LOD ${e} was aborted: ${u}`), null;
-        const _ = n, R = new Promise(async (d, g) => {
-          if (Dt) {
-            const x = await (await bt({})).load(u);
-            if (x.textures.length > 0)
-              for (const h of x.textures) {
-                let p = h.texture;
-                return m.assignLODInformation(r.url, p, o, e, void 0), t instanceof F && (p = this.copySettings(t, p)), p && (p.guid = _.guid), d(p);
+      const u = Array.isArray(a.lods) ? a.lods[e]?.path : a.lods;
+      if (!u)
+        return h && !a["missing:uri"] && (a["missing:uri"] = !0, console.warn("Missing uri for progressive asset for LOD " + e, a)), null;
+      const f = wt(n.url, u);
+      if (f.endsWith(".glb") || f.endsWith(".gltf")) {
+        if (!a.guid)
+          return console.warn("missing pointer for glb/gltf texture", a), null;
+        const c = f + "_" + a.guid, d = await this.tryResolveLODCacheEntry(this.cache.get(c), c, f, t, e, r);
+        if (d.found) return d.value;
+        if (s?.isCurrent?.() === !1)
+          return r && console.log(`Skipping stale LOD ${e} request before queue: ${f}`), null;
+        const p = await this.queue.slot(f);
+        if (s?.isCurrent?.() === !1)
+          return r && console.log(`Skipping stale LOD ${e} request after queue: ${f}`), null;
+        const b = await this.tryResolveLODCacheEntry(this.cache.get(c), c, f, t, e, r);
+        if (b.found) return b.value;
+        if (!p.use)
+          return h && console.log(`LOD ${e} was aborted: ${f}`), null;
+        const y = a, x = new Promise(async (w, z) => {
+          if (Ct) {
+            const m = await (await Rt({})).load(f);
+            if (m.textures.length > 0)
+              for (const D of m.textures) {
+                let M = D.texture;
+                return g.assignLODInformation(n.url, M, o, e, void 0), t instanceof q && (M = this.copySettings(t, M)), M && (M.guid = y.guid), w(M);
               }
-            if (x.geometries.length > 0) {
-              const h = new Array();
-              for (const p of x.geometries) {
-                const O = p.geometry;
-                m.assignLODInformation(r.url, O, o, e, p.primitiveIndex), h.push(O);
+            if (m.geometries.length > 0) {
+              const D = new Array();
+              for (const M of m.geometries) {
+                const G = M.geometry;
+                g.assignLODInformation(n.url, G, o, e, M.primitiveIndex), D.push(G);
               }
-              return d(h);
+              return w(D);
             }
-            return d(null);
+            return w(null);
           }
-          const b = new _e();
-          Re(b), f && (await new Promise((L) => setTimeout(L, 1e3)), s && console.warn("Start loading (delayed) " + u, _.guid));
-          let B = u;
-          if (_ && Array.isArray(_.lods)) {
-            const L = _.lods[e];
-            L.hash && (B += "?v=" + L.hash);
+          const v = new De();
+          Ge(v), h && (await new Promise((_) => setTimeout(_, 1e3)), r && console.warn("Start loading (delayed) " + f, y.guid));
+          let T = f;
+          if (y && Array.isArray(y.lods)) {
+            const _ = y.lods[e];
+            _.hash && (T += "?v=" + _.hash);
           }
-          const D = await b.loadAsync(B).catch((L) => (console.error(`Error loading LOD ${e} from ${u}
-`, L), d(null)));
-          if (!D)
-            return d(null);
-          const q = D.parser;
-          s && console.log("Loading finished " + u, _.guid);
-          let T = 0;
-          if (D.parser.json.textures) {
-            let L = !1;
-            for (const x of D.parser.json.textures) {
-              if (x?.extensions) {
-                const h = x?.extensions[W];
-                if (h?.guid && h.guid === _.guid) {
-                  L = !0;
+          const O = await v.loadAsync(T).catch((_) => (console.error(`Error loading LOD ${e} from ${f}
+`, _), w(null)));
+          if (!O)
+            return w(null);
+          const P = O.parser;
+          r && console.log("Loading finished " + f, y.guid);
+          let S = 0;
+          if (O.parser.json.textures) {
+            let _ = !1;
+            for (const m of O.parser.json.textures) {
+              if (m?.extensions) {
+                const D = m?.extensions[U];
+                if (D?.guid && D.guid === y.guid) {
+                  _ = !0;
                   break;
                 }
               }
-              T++;
+              S++;
             }
-            if (L) {
-              let x = await q.getDependency("texture", T);
-              return x && m.assignLODInformation(r.url, x, o, e, void 0), s && console.log('change "' + t.name + '" → "' + x.name + '"', u, T, x, c), t instanceof F && (x = this.copySettings(t, x)), x && (x.guid = _.guid), d(x);
-            } else f && console.warn("Could not find texture with guid", _.guid, D.parser.json);
+            if (_) {
+              let m = await P.getDependency("texture", S);
+              return m && g.assignLODInformation(n.url, m, o, e, void 0), r && console.log('change "' + t.name + '" → "' + m.name + '"', f, S, m, c), t instanceof q && (m = this.copySettings(t, m)), m && (m.guid = y.guid), w(m);
+            } else h && console.warn("Could not find texture with guid", y.guid, O.parser.json);
           }
-          if (T = 0, D.parser.json.meshes) {
-            let L = !1;
-            for (const x of D.parser.json.meshes) {
-              if (x?.extensions) {
-                const h = x?.extensions[W];
-                if (h?.guid && h.guid === _.guid) {
-                  L = !0;
+          if (S = 0, O.parser.json.meshes) {
+            let _ = !1;
+            for (const m of O.parser.json.meshes) {
+              if (m?.extensions) {
+                const D = m?.extensions[U];
+                if (D?.guid && D.guid === y.guid) {
+                  _ = !0;
                   break;
                 }
               }
-              T++;
+              S++;
             }
-            if (L) {
-              const x = await q.getDependency("mesh", T);
-              if (s && console.log(`Loaded Mesh "${x.name}"`, u, T, x, c), x.isMesh === !0) {
-                const h = x.geometry;
-                return m.assignLODInformation(r.url, h, o, e, 0), d(h);
+            if (_) {
+              const m = await P.getDependency("mesh", S);
+              if (r && console.log(`Loaded Mesh "${m.name}"`, f, S, m, c), m.isMesh === !0) {
+                const D = m.geometry;
+                return g.assignLODInformation(n.url, D, o, e, 0), w(D);
               } else {
-                const h = new Array();
-                for (let p = 0; p < x.children.length; p++) {
-                  const O = x.children[p];
-                  if (O.isMesh === !0) {
-                    const S = O.geometry;
-                    m.assignLODInformation(r.url, S, o, e, p), h.push(S);
+                const D = new Array();
+                for (let M = 0; M < m.children.length; M++) {
+                  const G = m.children[M];
+                  if (G.isMesh === !0) {
+                    const ie = G.geometry;
+                    g.assignLODInformation(n.url, ie, o, e, M), D.push(ie);
                   }
                 }
-                return d(h);
+                return w(D);
               }
-            } else f && console.warn("Could not find mesh with guid", _.guid, D.parser.json);
+            } else h && console.warn("Could not find mesh with guid", y.guid, O.parser.json);
           }
-          return d(null);
+          return w(null);
         });
-        this.cache.set(c, R), y.use(R);
-        const M = await R;
-        return M != null ? M instanceof F ? (this.cache.set(c, new WeakRef(M)), m._resourceRegistry.register(M, c)) : Array.isArray(M) ? this.cache.set(c, Promise.resolve(M)) : this.cache.set(c, Promise.resolve(M)) : this.cache.set(c, Promise.resolve(null)), M;
-      } else if (t instanceof F) {
-        s && console.log("Load texture from uri: " + u);
-        const y = await new Je().loadAsync(u);
-        return y ? (y.guid = n.guid, y.flipY = !1, y.needsUpdate = !0, y.colorSpace = t.colorSpace, s && console.log(n, y)) : f && console.warn("failed loading", u), y;
+        this.cache.set(c, x), p.use(x);
+        const L = await x;
+        return L != null ? L instanceof q ? (this.cache.set(c, new WeakRef(L)), g._resourceRegistry.register(L, c)) : Array.isArray(L) ? this.cache.set(c, Promise.resolve(L)) : this.cache.set(c, Promise.resolve(L)) : this.cache.set(c, Promise.resolve(null)), L;
+      } else if (t instanceof q) {
+        if (s?.isCurrent?.() === !1)
+          return r && console.log(`Skipping stale texture LOD ${e} request: ${f}`), null;
+        r && console.log("Load texture from uri: " + f);
+        const d = await new it().loadAsync(f);
+        return s?.isCurrent?.() === !1 ? (d?.dispose(), null) : (d ? (d.guid = a.guid, d.flipY = !1, d.needsUpdate = !0, d.colorSpace = t.colorSpace, r && console.log(a, d)) : h && console.warn("failed loading", f), d);
       }
     }
     return null;
   }
-  static queue = new gt(ve() ? 20 : 50, { debug: f != !1 });
-  static assignLODInformation(t, e, s, r, o) {
+  static async tryResolveLODCacheEntry(t, e, s, r, n, o) {
+    if (t === void 0)
+      return { found: !1 };
+    if (o && console.log(`LOD ${n} was already loading/loaded: ${e}`), t instanceof WeakRef) {
+      const u = t.deref();
+      if (u) {
+        let f = u, c = !1;
+        if (f instanceof q && r instanceof q ? Te(f.image) || we(f) ? f = this.copySettings(r, f) : c = !0 : f instanceof j && r instanceof j && (f.attributes.position?.array || (c = !0)), !c)
+          return { found: !0, value: f };
+      }
+      return this.cache.delete(e), h && console.log(`[gltf-progressive] Re-loading GC'd/disposed resource: ${e}`), { found: !1 };
+    }
+    let a = await t.catch((u) => (console.error(`Error loading LOD ${n} from ${s}
+`, u), null)), l = !1;
+    return a == null || (a instanceof q && r instanceof q ? Te(a.image) || we(a) ? a = this.copySettings(r, a) : (l = !0, this.cache.delete(e)) : a instanceof j && r instanceof j && (a.attributes.position?.array || (l = !0, this.cache.delete(e)))), l ? { found: !1 } : { found: !0, value: a };
+  }
+  static _queue;
+  static get queue() {
+    return this._queue ??= new Lt(Me() ? 20 : 50, { debug: h != !1 });
+  }
+  static assignLODInformation(t, e, s, r, n) {
     if (!e) return;
     e.userData || (e.userData = {});
-    const n = new Ot(t, s, r, o);
-    e.userData.LODS = n, "source" in e && typeof e.source == "object" && (e.source.LODS = n);
+    const o = new kt(t, s, r, n);
+    e.userData.LODS = o, "source" in e && typeof e.source == "object" && (e.source.LODS = o);
   }
   static getAssignedLODInformation(t) {
     return t ? t.userData?.LODS ? t.userData.LODS : "source" in t && t.source?.LODS ? t.source.LODS : null : null;
   }
   // private static readonly _copiedTextures: WeakMap<Texture, Texture> = new Map();
   static copySettings(t, e) {
-    return e ? (f === "verbose" && console.debug(`Copy texture settings
+    return e ? (h === "verbose" && console.debug(`Copy texture settings
 `, t.uuid, `
 `, e.uuid), e = e.clone(), e.offset = t.offset, e.repeat = t.repeat, e.colorSpace = t.colorSpace, e.magFilter = t.magFilter, e.minFilter = t.minFilter, e.wrapS = t.wrapS, e.wrapT = t.wrapT, e.flipY = t.flipY, e.anisotropy = t.anisotropy, e.mipmaps || (e.generateMipmaps = t.generateMipmaps), e) : t;
   }
 }
-class Ot {
+class kt {
   url;
   /** the key to lookup the LOD information */
   key;
@@ -921,10 +1103,10 @@ class Ot {
     this.url = t, this.key = e, this.level = s, r != null && (this.index = r);
   }
 }
-class ce {
+class oe {
   static addPromise = (t, e, s, r) => {
-    r.forEach((o) => {
-      o.add(t, e, s);
+    r.forEach((n) => {
+      n.add(t, e, s);
     });
   };
   ready;
@@ -955,8 +1137,8 @@ class ce {
   _maxPromisesPerObject = 1;
   constructor(t, e) {
     const r = Math.max(e.frames ?? 2, 2);
-    this._frame_start = e.waitForFirstCapture ? void 0 : t, this._frames_to_capture = r, this.ready = new Promise((o) => {
-      this._resolve = o;
+    this._frame_start = e.waitForFirstCapture ? void 0 : t, this._frames_to_capture = r, this.ready = new Promise((n) => {
+      this._resolve = n;
     }), this.ready.finally(() => {
       this._resolved = !0, this._awaiting.length = 0;
     }), this._signal = e.signal, this._signal?.addEventListener("abort", () => {
@@ -970,15 +1152,15 @@ class ce {
   _seen = /* @__PURE__ */ new WeakMap();
   add(t, e, s) {
     if (this._resolved) {
-      f && console.warn("PromiseGroup: Trying to add a promise to a resolved group, ignoring.");
+      h && console.warn("PromiseGroup: Trying to add a promise to a resolved group, ignoring.");
       return;
     }
     if (!(this._frame_start !== void 0 && this._currentFrame > this._frame_start + this._frames_to_capture)) {
       if (this._maxPromisesPerObject >= 1)
         if (this._seen.has(e)) {
-          let r = this._seen.get(e);
+          const r = this._seen.get(e);
           if (r >= this._maxPromisesPerObject) {
-            f && console.warn("PromiseGroup: Already awaiting object ignoring new promise for it.");
+            h && console.warn("PromiseGroup: Already awaiting object ignoring new promise for it.");
             return;
           }
           this._seen.set(e, r + 1);
@@ -997,22 +1179,122 @@ class ce {
     });
   }
 }
-const k = N("debugprogressive"), St = N("noprogressive"), de = /* @__PURE__ */ Symbol("Needle:LODSManager"), fe = /* @__PURE__ */ Symbol("Needle:LODState"), U = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), P = { mesh_lod: -1, texture_lod: -1 };
-class v {
+const A = V("debugprogressive"), At = A === "colors", It = V("noprogressive"), he = /* @__PURE__ */ Symbol("Needle:LODSManager"), ge = /* @__PURE__ */ Symbol("Needle:LODState"), E = /* @__PURE__ */ Symbol("Needle:CurrentLOD"), Oe = Xe, R = { mesh_lod: -1, texture_lod: -1 }, $t = new Ie(), Se = [
+  3526751,
+  11065402,
+  15978811,
+  15897394,
+  15749691,
+  11032304,
+  4827122,
+  3332036,
+  16739229,
+  7306743,
+  14053330,
+  3516499,
+  12035359,
+  14703919,
+  3963096,
+  42662,
+  14100029,
+  8344319,
+  4633680,
+  16229681,
+  3120096,
+  12076434,
+  9083434,
+  2060171,
+  15751837,
+  10182117,
+  48121,
+  62932,
+  16704576,
+  15817653,
+  5083278,
+  5592405
+];
+function Bt() {
+  const i = Oe.Timer || Oe.Clock;
+  return new i();
+}
+const pe = new ue(), N = new ue(), Re = new ue(), Gt = new k(), qt = new k(), Wt = new $e(), W = new k(), Y = new k(), Q = new k(), J = new k();
+function Ft(i, t) {
+  const e = i.min, s = i.max, r = (e.x + s.x) * 0.5, n = (e.y + s.y) * 0.5;
+  return W.set(r, n, e.z).applyMatrix4(t).z < 0;
+}
+function Ut(i) {
+  const {
+    geometry: t,
+    matrixWorld: e,
+    camera: s,
+    projectionScreenMatrix: r,
+    desiredDensity: n,
+    canvasHeight: o = 0,
+    currentLevel: a = -1,
+    xrEnabled: l = !1,
+    debugDrawLine: u,
+    warnMissingPrimitiveDensities: f = !1
+  } = i, c = g.getMeshLODExtension(t)?.lods, d = g.getPrimitiveIndex(t), p = i.target ?? {
+    level: a,
+    primitiveIndex: d,
+    screenCoverage: 0,
+    screenspaceVolume: new k(),
+    centrality: 1
+  };
+  p.level = a, p.primitiveIndex = d, p.screenCoverage = 0, p.screenspaceVolume.set(0, 0, 0), p.centrality = 1;
+  let b = i.boundingBox ?? t.boundingBox;
+  if (b || (t.computeBoundingBox(), b = t.boundingBox), !b) return p;
+  if (pe.copy(b).applyMatrix4(e), s.isPerspectiveCamera && Ft(pe, r))
+    return p.level = 0, p.screenCoverage = 1 / 0, p.screenspaceVolume.set(1 / 0, 1 / 0, 1 / 0), p;
+  if (N.copy(pe).applyMatrix4(r), l && s.isPerspectiveCamera && s.fov > 70) {
+    const v = N.min, T = N.max;
+    let O = v.x, P = v.y, S = T.x, _ = T.y;
+    const m = 2, D = 1.5, M = (v.x + T.x) * 0.5, G = (v.y + T.y) * 0.5;
+    O = (O - M) * m + M, P = (P - G) * m + G, S = (S - M) * m + M, _ = (_ - G) * m + G;
+    const ie = O < 0 && S > 0 ? 0 : Math.min(Math.abs(v.x), Math.abs(T.x)), Ve = P < 0 && _ > 0 ? 0 : Math.min(Math.abs(v.y), Math.abs(T.y)), ce = Math.max(ie, Ve);
+    p.centrality = (D - ce) * (D - ce) * (D - ce);
+  }
+  const y = N.getSize(Gt);
+  y.multiplyScalar(0.5), globalThis.screen?.availHeight > 0 && o > 0 && y.multiplyScalar(o / globalThis.screen.availHeight), s.isPerspectiveCamera && (y.x *= s.aspect), Re.copy(b).applyMatrix4(e).applyMatrix4(s.matrixWorldInverse);
+  const x = Re.getSize(qt), L = Math.max(y.x, y.y), w = Math.max(x.x, x.y);
+  L !== 0 && w !== 0 && (y.z = x.z / w * L);
+  const z = Math.max(y.x, y.y, y.z) * p.centrality;
+  if (p.screenCoverage = z, p.screenspaceVolume.copy(y), z <= 0) return p;
+  if (u) {
+    const v = Wt.copy(r);
+    v.invert(), W.copy(N.min), Y.copy(N.max), Y.x = W.x, Q.copy(N.max), Q.y = W.y, J.copy(N.max);
+    const T = (W.z + J.z) * 0.5;
+    W.z = Y.z = Q.z = J.z = T, W.applyMatrix4(v), Y.applyMatrix4(v), Q.applyMatrix4(v), J.applyMatrix4(v), u(W, Y, 255), u(W, Q, 255), u(Y, J, 255), u(Q, J, 255);
+  }
+  if (c?.length)
+    for (let v = 0; v < c.length; v++) {
+      const T = c[v], O = T.densities?.[d] || T.density || 1e-5;
+      if (d > 0 && f && Fe() && !T.densities && !globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] && (globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] = !0, console.warn("[Needle Progressive] Detected usage of mesh without primitive densities. This might cause incorrect LOD level selection: Consider re-optimizing your model by updating your Needle Integration, Needle glTF Pipeline or running optimization again on Needle Cloud.")), O / z < n) {
+        p.level = v;
+        break;
+      }
+    }
+  return p;
+}
+class I {
   /** 
    * Assign a function to draw debug lines for the LODs. This function will be called with the start and end position of the line and the color of the line when the `debugprogressive` query parameter is set.
    */
   static debugDrawLine;
   /** @internal */
   static getObjectLODState(t) {
-    return t[fe];
+    return t[ge];
   }
   static addPlugin(t) {
-    z.push(t);
+    F.push(t);
   }
   static removePlugin(t) {
-    const e = z.indexOf(t);
-    e >= 0 && z.splice(e, 1);
+    const e = F.indexOf(t);
+    e >= 0 && F.splice(e, 1);
+  }
+  /** Read-only snapshot of the currently registered plugins, for inspection. Use {@link addPlugin} / {@link removePlugin} to modify the registry. */
+  static getPlugins() {
+    return F;
   }
   /**
    * Gets the LODsManager for the given renderer. If the LODsManager does not exist yet, it will be created.  
@@ -1020,20 +1302,20 @@ class v {
    * @returns The LODsManager instance.
    */
   static get(t, e) {
-    if (t[de])
-      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[de];
-    const s = new v(t, {
+    if (t[he])
+      return console.debug("[gltf-progressive] LODsManager already exists for this renderer"), t[he];
+    const s = new I(t, {
       engine: "unknown",
       ...e
     });
-    return t[de] = s, s;
+    return t[he] = s, s;
   }
   renderer;
   context;
-  projectionScreenMatrix = new Me();
+  projectionScreenMatrix = new $e();
   /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
   get plugins() {
-    return z;
+    return F;
   }
   /**
    * Force override the LOD level for all objects (meshes + textures) rendered in the scene
@@ -1071,45 +1353,99 @@ class v {
   _newPromiseGroups = [];
   _promiseGroupIds = 0;
   /**
-   * Call to await LODs loading during the next render cycle.
+   * Returns a promise that resolves once all LOD requests initiated during the next render cycles have finished loading.
+   * This is useful for hiding low-resolution placeholders (e.g. with a loading overlay or CSS blur) until high-quality assets are ready.
+   *
+   * By default, the returned promise captures LOD loading requests for 2 frames and resolves when all of them complete.
+   * Use `waitForFirstCapture` if no LOD requests may happen immediately (e.g. after a scene switch).
+   *
+   * @param opts - Optional configuration for how long to capture and what to wait for. See {@link PromiseGroupOptions}.
+   * @returns A promise that resolves with `{ cancelled, awaited_count, resolved_count }` once all captured LOD loads complete (or the signal aborts).
+   *
+   * @example
+   * ```ts
+   * // Wait for initial LODs to finish loading, then remove a blur overlay
+   * const result = await lodsManager.awaitLoading({
+   *     frames: 5,
+   *     signal: AbortSignal.timeout(10_000),
+   * });
+   * console.log(`Loaded ${result.resolved_count} of ${result.awaited_count} LODs`);
+   * document.querySelector('.blur-overlay')?.remove();
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Wait until at least one LOD starts loading before resolving
+   * await lodsManager.awaitLoading({ waitForFirstCapture: true });
+   * ```
    */
   awaitLoading(t) {
-    const e = this._promiseGroupIds++, s = new ce(this.#r, { ...t });
+    const e = this._promiseGroupIds++, s = new oe(this.#r, { ...t });
     this._newPromiseGroups.push(s);
     const r = performance.now();
     return s.ready.finally(() => {
-      const o = this._newPromiseGroups.indexOf(s);
-      o >= 0 && (this._newPromiseGroups.splice(o, 1), Oe() && performance.measure("LODsManager:awaitLoading", {
+      const n = this._newPromiseGroups.indexOf(s);
+      n >= 0 && (this._newPromiseGroups.splice(n, 1), Fe() && performance.measure("LODsManager:awaitLoading", {
         start: r,
         detail: { id: e, name: t?.name, awaited: s.awaitedCount, resolved: s.resolvedCount }
       }));
     }), s.ready;
   }
+  /** Track LOD work started outside this manager so {@link awaitLoading} waits for it too. */
+  trackLoadingPromise(t, e, s) {
+    return oe.addPromise(t, e, s, this._newPromiseGroups), s;
+  }
   _postprocessPromiseGroups() {
     if (this._newPromiseGroups.length !== 0)
       for (let t = this._newPromiseGroups.length - 1; t >= 0; t--)
         this._newPromiseGroups[t].update(this.#r);
   }
   _lodchangedlisteners = [];
+  /**
+   * Register a listener that is called whenever a mesh or texture LOD level has finished loading and has been applied.
+   * The listener receives the type of asset (`"mesh"` or `"texture"`), the new LOD level, and the affected object.
+   *
+   * @param evt - The event type. Currently only `"changed"` is supported.
+   * @param listener - Callback invoked after a LOD swap completes.
+   * @return A function to unregister the listener.
+   *
+   * @example
+   * ```ts
+   * lodsManager.addEventListener("changed", ({ type, level, object }) => {
+   *     console.log(`${type} LOD changed to level ${level}`, object);
+   * });
+   * ```
+   */
   addEventListener(t, e) {
-    t === "changed" && this._lodchangedlisteners.push(e);
+    return t === "changed" ? (this._lodchangedlisteners.push(e), () => {
+      this.removeEventListener(t, e);
+    }) : () => {
+    };
   }
+  /**
+   * Remove a previously registered `"changed"` event listener.
+   * @param evt - The event type (`"changed"`).
+   * @param listener - The listener to remove.
+   * @return `true` if the listener was found and removed, `false` otherwise.
+   */
   removeEventListener(t, e) {
+    let s = !1;
     if (t === "changed") {
-      const s = this._lodchangedlisteners.indexOf(e);
-      s >= 0 && this._lodchangedlisteners.splice(s, 1);
+      const r = this._lodchangedlisteners.indexOf(e);
+      r >= 0 && (this._lodchangedlisteners.splice(r, 1), s = !0);
     }
+    return s;
   }
   // readonly plugins: NEEDLE_progressive_plugin[] = [];
   constructor(t, e) {
     this.renderer = t, this.context = { ...e };
   }
   #t;
-  #n = new Ze();
   #r = 0;
+  #n = 0;
   #o = 0;
-  #i = 0;
   #s = 0;
+  #i = Bt();
   _fpsBuffer = [60, 60, 60, 60, 60];
   /**
    * Enable the LODsManager. This will replace the render method of the renderer with a method that updates the LODs.
@@ -1120,29 +1456,46 @@ class v {
     let t = 0;
     this.#t = this.renderer.render;
     const e = this;
-    Le(this.renderer), this.renderer.render = function(s, r) {
-      const o = e.renderer.getRenderTarget();
-      (o == null || "isXRRenderTarget" in o && o.isXRRenderTarget) && (t = 0, e.#r += 1, e.#n.update(), e.#o = e.#n.getDelta(), e.#i += e.#o, e._fpsBuffer.shift(), e._fpsBuffer.push(1 / e.#o), e.#s = e._fpsBuffer.reduce((l, a) => l + a) / e._fpsBuffer.length, k && e.#r % 200 === 0 && console.log("FPS", Math.round(e.#s), "Interval:", e.#e));
-      const n = t++;
-      e.#t.call(this, s, r), e.onAfterRender(s, r, n);
+    _e(this.renderer), this.renderer.render = function(s, r) {
+      const n = e.renderer.getRenderTarget();
+      (n == null || "isXRRenderTarget" in n && n.isXRRenderTarget) && (t = 0, e.#r += 1, e.#i.update?.(), e.#n = Math.max(e.#i.getDelta(), 1 / 1e3), e.#o += e.#n, e._fpsBuffer.shift(), e._fpsBuffer.push(1 / e.#n), e.#s = e._fpsBuffer.reduce((a, l) => a + l) / e._fpsBuffer.length, A && e.#r % 200 === 0 && console.log("FPS", Math.round(e.#s), "Interval:", e.#e));
+      const o = t++;
+      e.#t.call(this, s, r), e.onAfterRender(s, r, o);
     };
   }
   disable() {
     this.#t && (console.debug("[gltf-progressive] Disabling LODsManager for renderer"), this.renderer.render = this.#t, this.#t = void 0);
   }
+  /**
+   * Manually trigger a LOD update for a scene and camera.
+   * Only needed when {@link manual} is set to `true` — otherwise LOD updates happen automatically on each render call.
+   *
+   * @param scene - The scene containing objects with progressive LODs.
+   * @param camera - The camera used to determine screen coverage and LOD levels.
+   *
+   * @example
+   * ```ts
+   * const lodsManager = LODsManager.get(renderer);
+   * lodsManager.manual = true;
+   * // ... later, trigger an update at a specific point:
+   * lodsManager.update(scene, camera);
+   * ```
+   */
   update(t, e) {
     this.internalUpdate(t, e);
   }
   onAfterRender(t, e, s) {
     if (this.pause) return;
-    const o = this.renderer.renderLists.get(t, 0).opaque;
-    let n = !0;
-    if (o.length === 1) {
-      const l = o[0].material;
-      (l.name === "EffectMaterial" || l.name === "CopyShader") && (n = !1);
+    const r = this.getRenderList(t, e, s);
+    if (!r) return;
+    const n = r.opaque;
+    let o = !0;
+    if (n.length === 1) {
+      const a = n[0].material;
+      (a.name === "EffectMaterial" || a.name === "CopyShader") && (o = !1);
     }
-    if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (n = !1), n) {
-      if (St || (this.updateInterval === "auto" ? this.#s < 40 && this.#e < 10 ? (this.#e += 1, k && console.warn("↓ Reducing LOD updates", this.#e, this.#s.toFixed(0))) : this.#s >= 60 && this.#e > 1 && (this.#e -= 1, k && console.warn("↑ Increasing LOD updates", this.#e, this.#s.toFixed(0))) : this.#e = this.updateInterval, this.#e > 0 && this.#r % this.#e != 0))
+    if ((e.parent && e.parent.type === "CubeCamera" || s >= 1 && e.type === "OrthographicCamera") && (o = !1), o) {
+      if (It || (this.updateInterval === "auto" ? this.#s < 40 && this.#e < 10 ? (this.#e += 1, A && console.warn("↓ Reducing LOD updates", this.#e, this.#s.toFixed(0))) : this.#s >= 60 && this.#e > 1 && (this.#e -= 1, A && console.warn("↑ Increasing LOD updates", this.#e, this.#s.toFixed(0))) : this.#e = this.updateInterval, this.#e > 0 && this.#r % this.#e != 0))
         return;
       this.internalUpdate(t, e), this._postprocessPromiseGroups();
     }
@@ -1151,15 +1504,17 @@ class v {
    * Update LODs in a scene
    */
   internalUpdate(t, e) {
-    const s = this.renderer.renderLists.get(t, 0), r = s.opaque;
+    const s = this.getRenderList(t, e, 0);
+    if (!s) return;
+    const r = s.opaque;
     this.projectionScreenMatrix.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse);
-    const o = this.targetTriangleDensity;
-    for (const a of r) {
-      if (a.material && (a.geometry?.type === "BoxGeometry" || a.geometry?.type === "BufferGeometry") && (a.material.name === "SphericalGaussianBlur" || a.material.name == "BackgroundCubeMaterial" || a.material.name === "CubemapFromEquirect" || a.material.name === "EquirectangularToCubeUV")) {
-        k && (a.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] || (a.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] = !0, console.warn("Ignoring skybox or BLIT object", a, a.material.name, a.material.type)));
+    const n = this.targetTriangleDensity;
+    for (const l of r) {
+      if (l.material && (l.geometry?.type === "BoxGeometry" || l.geometry?.type === "BufferGeometry") && (l.material.name === "SphericalGaussianBlur" || l.material.name == "BackgroundCubeMaterial" || l.material.name === "CubemapFromEquirect" || l.material.name === "EquirectangularToCubeUV")) {
+        A && (l.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] || (l.material["NEEDLE_PROGRESSIVE:IGNORE-WARNING"] = !0, console.warn("Ignoring skybox or BLIT object", l, l.material.name, l.material.type)));
         continue;
       }
-      switch (a.material.type) {
+      switch (l.material.type) {
         case "LineBasicMaterial":
         case "LineDashedMaterial":
         case "PointsMaterial":
@@ -1168,38 +1523,52 @@ class v {
         case "MeshDepthMaterial":
           continue;
       }
-      if (k === "color" && a.material && !a.object.progressive_debug_color) {
-        a.object.progressive_debug_color = !0;
-        const c = Math.random() * 16777215, y = new et({ color: c });
-        a.object.material = y;
-      }
-      const u = a.object;
-      (u instanceof j || u.isMesh) && this.updateLODs(t, e, u, o);
+      const u = l.object;
+      (u instanceof K || u.isMesh) && this.updateLODs(t, e, u, n);
     }
-    const n = s.transparent;
-    for (const a of n) {
-      const u = a.object;
-      (u instanceof j || u.isMesh) && this.updateLODs(t, e, u, o);
+    const o = s.transparent;
+    for (const l of o) {
+      const u = l.object;
+      (u instanceof K || u.isMesh) && this.updateLODs(t, e, u, n);
     }
-    const l = s.transmissive;
-    for (const a of l) {
-      const u = a.object;
-      (u instanceof j || u.isMesh) && this.updateLODs(t, e, u, o);
+    const a = s.transmissive;
+    for (const l of a) {
+      const u = l.object;
+      (u instanceof K || u.isMesh) && this.updateLODs(t, e, u, n);
     }
   }
+  getRenderList(t, e, s) {
+    const r = this.renderer;
+    let n = null;
+    if (r.isWebGPURenderer === !0) {
+      const o = r._renderLists;
+      if (!o) return null;
+      n = o.get(t, e);
+    } else if (r.isWebGLRenderer === !0) {
+      const o = r.renderLists;
+      if (!o) return null;
+      n = o.get(t, s);
+    }
+    return n ? {
+      opaque: n.opaque || [],
+      transparent: n.transparent || [],
+      transmissive: n.transmissive || n.transparentDoublePass || [],
+      transparentDoublePass: n.transparentDoublePass || []
+    } : null;
+  }
   /** Update the LOD levels for the renderer. */
   updateLODs(t, e, s, r) {
     s.userData || (s.userData = {});
-    let o = s[fe];
-    if (o || (o = new Tt(), s[fe] = o), o.frames++ < 2)
+    let n = s[ge];
+    if (n || (n = new zt(), s[ge] = n), n.frames++ < 2)
       return;
-    for (const l of z)
-      l.onBeforeUpdateLOD?.(this.renderer, t, e, s);
-    const n = this.overrideLodLevel !== void 0 ? this.overrideLodLevel : V;
-    n >= 0 ? (P.mesh_lod = n, P.texture_lod = n) : (this.calculateLodLevel(e, s, o, r, P), P.mesh_lod = Math.round(P.mesh_lod), P.texture_lod = Math.round(P.texture_lod)), P.mesh_lod >= 0 && this.loadProgressiveMeshes(s, P.mesh_lod), s.material && P.texture_lod >= 0 && this.loadProgressiveTextures(s.material, P.texture_lod, n), f && s.material && !s.isGizmo && $e(s.material);
-    for (const l of z)
-      l.onAfterUpdatedLOD?.(this.renderer, t, e, s, P);
-    o.lastLodLevel_Mesh = P.mesh_lod, o.lastLodLevel_Texture = P.texture_lod;
+    for (const a of F)
+      a.onBeforeUpdateLOD?.(this.renderer, t, e, s);
+    const o = this.overrideLodLevel !== void 0 ? this.overrideLodLevel : X;
+    o >= 0 ? (R.mesh_lod = o, R.texture_lod = o) : (this.calculateLodLevel(e, s, n, r, R), R.mesh_lod = Math.round(R.mesh_lod), R.texture_lod = Math.round(R.texture_lod)), R.mesh_lod >= 0 && this.loadProgressiveMeshes(s, R.mesh_lod), s.material && R.texture_lod >= 0 && this.loadProgressiveTextures(s.material, R.texture_lod, o), h && s.material && !s.isGizmo && Ue(s.material), At && s.material && !s.isGizmo && !s.isBatchedMesh && ze(s.material, R.mesh_lod);
+    for (const a of F)
+      a.onAfterUpdatedLOD?.(this.renderer, t, e, s, R);
+    n.lastLodLevel_Mesh = R.mesh_lod, n.lastLodLevel_Texture = R.texture_lod;
   }
   /** Load progressive textures for the given material
    * @param material the material to load the textures for
@@ -1210,16 +1579,18 @@ class v {
     if (!t) return;
     if (Array.isArray(t)) {
       for (const o of t)
-        this.loadProgressiveTextures(o, e);
+        this.loadProgressiveTextures(o, e, s);
       return;
     }
     let r = !1;
-    if ((t[U] === void 0 || e < t[U]) && (r = !0), s !== void 0 && s >= 0 && (r = t[U] != s, e = s), r) {
-      t[U] = e;
-      const o = m.assignTextureLOD(t, e).then((n) => {
-        this._lodchangedlisteners.forEach((l) => l({ type: "texture", level: e, object: t }));
+    (t[E] === void 0 || e < t[E]) && (r = !0);
+    const n = s !== void 0 && s >= 0;
+    if (n && (r = t[E] != s, e = s), r) {
+      t[E] = e;
+      const o = n ? { force: !0 } : void 0, a = g.assignTextureLOD(t, e, o).then((l) => {
+        this._lodchangedlisteners.forEach((u) => u({ type: "texture", level: e, object: t }));
       });
-      ce.addPromise("texture", t, o, this._newPromiseGroups);
+      oe.addPromise("texture", t, a, this._newPromiseGroups);
     }
   }
   /** Load progressive meshes for the given mesh
@@ -1230,143 +1601,110 @@ class v {
    */
   loadProgressiveMeshes(t, e) {
     if (!t) return Promise.resolve(null);
-    let s = t[U] !== e;
+    let s = t[E] !== e;
     const r = t["DEBUG:LOD"];
-    if (r != null && (s = t[U] != r, e = r), s) {
-      t[U] = e;
-      const o = t.geometry, n = m.assignMeshLOD(t, e).then((l) => (l && t[U] == e && o != t.geometry && this._lodchangedlisteners.forEach((a) => a({ type: "mesh", level: e, object: t })), l));
-      return ce.addPromise("mesh", t, n, this._newPromiseGroups), n;
+    if (r != null && (s = t[E] != r, e = r), s) {
+      t[E] = e;
+      const n = t.geometry, o = g.assignMeshLOD(t, e).then((a) => (a && t[E] == e && n != t.geometry && this._lodchangedlisteners.forEach((l) => l({ type: "mesh", level: e, object: t })), a));
+      return oe.addPromise("mesh", t, o, this._newPromiseGroups), o;
     }
     return Promise.resolve(null);
   }
   // private testIfLODLevelsAreAvailable() {
-  _sphere = new Ce();
-  _tempBox = new ge();
-  _tempBox2 = new ge();
-  tempMatrix = new Me();
-  _tempWorldPosition = new A();
-  _tempBoxSize = new A();
-  _tempBox2Size = new A();
-  static corner0 = new A();
-  static corner1 = new A();
-  static corner2 = new A();
-  static corner3 = new A();
-  static _tempPtInside = new A();
-  static isInside(t, e) {
-    const s = t.min, r = t.max, o = (s.x + r.x) * 0.5, n = (s.y + r.y) * 0.5;
-    return this._tempPtInside.set(o, n, s.z).applyMatrix4(e).z < 0;
-  }
+  _sphere = new Ae();
+  _tempWorldPosition = new k();
   static skinnedMeshBoundsFrameOffsetCounter = 0;
   static $skinnedMeshBoundsOffset = /* @__PURE__ */ Symbol("gltf-progressive-skinnedMeshBoundsOffset");
   // #region calculateLodLevel
-  calculateLodLevel(t, e, s, r, o) {
+  calculateLodLevel(t, e, s, r, n) {
     if (!e) {
-      o.mesh_lod = -1, o.texture_lod = -1;
+      n.mesh_lod = -1, n.texture_lod = -1;
       return;
     }
     if (!t) {
-      o.mesh_lod = -1, o.texture_lod = -1;
+      n.mesh_lod = -1, n.texture_lod = -1;
       return;
     }
-    let l = 10 + 1, a = !1;
-    if (k && e["DEBUG:LOD"] != null)
+    let a = 10 + 1, l = !1;
+    if (A && e["DEBUG:LOD"] != null)
       return e["DEBUG:LOD"];
-    const u = m.getMeshLODExtension(e.geometry)?.lods, c = m.getPrimitiveIndex(e.geometry), y = u && u.length > 0, w = m.getMaterialMinMaxLODsCount(e.material), _ = w.min_count !== 1 / 0 && w.min_count >= 0 && w.max_count >= 0;
-    if (!y && !_) {
-      o.mesh_lod = 0, o.texture_lod = 0;
+    const u = g.getMeshLODExtension(e.geometry)?.lods, f = g.getPrimitiveIndex(e.geometry), c = u && u.length > 0, d = g.getMaterialMinMaxLODsCount(e.material), p = d.min_count !== 1 / 0 && d.min_count >= 0 && d.max_count >= 0;
+    if (!c && !p) {
+      n.mesh_lod = 0, n.texture_lod = 0;
       return;
     }
-    y || (a = !0, l = 0);
-    const R = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
-    let M = e.geometry.boundingBox;
+    c || (l = !0, a = 0);
+    const b = this.renderer.domElement.clientHeight || this.renderer.domElement.height;
+    let y = e.geometry.boundingBox;
     if (e.type === "SkinnedMesh") {
-      const d = e;
-      if (!d.boundingBox)
-        d.computeBoundingBox();
+      const x = e;
+      if (!x.boundingBox)
+        x.computeBoundingBox();
       else if (this.skinnedMeshAutoUpdateBoundsInterval > 0) {
-        if (!d[v.$skinnedMeshBoundsOffset]) {
-          const b = v.skinnedMeshBoundsFrameOffsetCounter++;
-          d[v.$skinnedMeshBoundsOffset] = b;
+        if (!x[I.$skinnedMeshBoundsOffset]) {
+          const w = I.skinnedMeshBoundsFrameOffsetCounter++;
+          x[I.$skinnedMeshBoundsOffset] = w;
         }
-        const g = d[v.$skinnedMeshBoundsOffset];
-        if ((s.frames + g) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
-          const b = ee(d), B = d.geometry;
-          b && (d.geometry = b), d.computeBoundingBox(), d.geometry = B;
+        const L = x[I.$skinnedMeshBoundsOffset];
+        if ((s.frames + L) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
+          const w = ne(x), z = x.geometry;
+          w && (x.geometry = w), x.computeBoundingBox(), x.geometry = z;
         }
       }
-      M = d.boundingBox;
+      y = x.boundingBox;
     }
-    if (M) {
-      const d = t;
+    if (y) {
       if (e.geometry.attributes.color && e.geometry.attributes.color.count < 100 && e.geometry.boundingSphere) {
         this._sphere.copy(e.geometry.boundingSphere), this._sphere.applyMatrix4(e.matrixWorld);
-        const h = t.getWorldPosition(this._tempWorldPosition);
-        if (this._sphere.containsPoint(h)) {
-          o.mesh_lod = 0, o.texture_lod = 0;
+        const w = t.getWorldPosition(this._tempWorldPosition);
+        if (this._sphere.containsPoint(w)) {
+          n.mesh_lod = 0, n.texture_lod = 0;
           return;
         }
       }
-      if (this._tempBox.copy(M), this._tempBox.applyMatrix4(e.matrixWorld), d.isPerspectiveCamera && v.isInside(this._tempBox, this.projectionScreenMatrix)) {
-        o.mesh_lod = 0, o.texture_lod = 0;
+      const x = Ut({
+        geometry: e.geometry,
+        matrixWorld: e.matrixWorld,
+        camera: t,
+        projectionScreenMatrix: this.projectionScreenMatrix,
+        desiredDensity: r,
+        canvasHeight: b,
+        currentLevel: s.lastLodLevel_Mesh,
+        boundingBox: y,
+        xrEnabled: this.renderer.xr.enabled,
+        debugDrawLine: A ? I.debugDrawLine : void 0,
+        warnMissingPrimitiveDensities: !0
+      });
+      if (s.lastCentrality = x.centrality, s.lastScreenCoverage = x.screenCoverage, s.lastScreenspaceVolume.copy(x.screenspaceVolume), x.screenCoverage === 1 / 0) {
+        n.mesh_lod = 0, n.texture_lod = 0;
         return;
       }
-      if (this._tempBox.applyMatrix4(this.projectionScreenMatrix), this.renderer.xr.enabled && d.isPerspectiveCamera && d.fov > 70) {
-        const h = this._tempBox.min, p = this._tempBox.max;
-        let O = h.x, S = h.y, G = p.x, Y = p.y;
-        const te = 2, ie = 1.5, se = (h.x + p.x) * 0.5, re = (h.y + p.y) * 0.5;
-        O = (O - se) * te + se, S = (S - re) * te + re, G = (G - se) * te + se, Y = (Y - re) * te + re;
-        const Fe = O < 0 && G > 0 ? 0 : Math.min(Math.abs(h.x), Math.abs(p.x)), We = S < 0 && Y > 0 ? 0 : Math.min(Math.abs(h.y), Math.abs(p.y)), ae = Math.max(Fe, We);
-        s.lastCentrality = (ie - ae) * (ie - ae) * (ie - ae);
-      } else
-        s.lastCentrality = 1;
-      const g = this._tempBox.getSize(this._tempBoxSize);
-      g.multiplyScalar(0.5), screen.availHeight > 0 && R > 0 && g.multiplyScalar(R / screen.availHeight), t.isPerspectiveCamera ? g.x *= t.aspect : t.isOrthographicCamera;
-      const b = t.matrixWorldInverse, B = this._tempBox2;
-      B.copy(M), B.applyMatrix4(e.matrixWorld), B.applyMatrix4(b);
-      const D = B.getSize(this._tempBox2Size), q = Math.max(D.x, D.y);
-      if (Math.max(g.x, g.y) != 0 && q != 0 && (g.z = D.z / Math.max(D.x, D.y) * Math.max(g.x, g.y)), s.lastScreenCoverage = Math.max(g.x, g.y, g.z), s.lastScreenspaceVolume.copy(g), s.lastScreenCoverage *= s.lastCentrality, k && v.debugDrawLine) {
-        const h = this.tempMatrix.copy(this.projectionScreenMatrix);
-        h.invert();
-        const p = v.corner0, O = v.corner1, S = v.corner2, G = v.corner3;
-        p.copy(this._tempBox.min), O.copy(this._tempBox.max), O.x = p.x, S.copy(this._tempBox.max), S.y = p.y, G.copy(this._tempBox.max);
-        const Y = (p.z + G.z) * 0.5;
-        p.z = O.z = S.z = G.z = Y, p.applyMatrix4(h), O.applyMatrix4(h), S.applyMatrix4(h), G.applyMatrix4(h), v.debugDrawLine(p, O, 255), v.debugDrawLine(p, S, 255), v.debugDrawLine(O, G, 255), v.debugDrawLine(S, G, 255);
-      }
-      let L = 999;
-      if (u && s.lastScreenCoverage > 0)
-        for (let h = 0; h < u.length; h++) {
-          const p = u[h], S = (p.densities?.[c] || p.density || 1e-5) / s.lastScreenCoverage;
-          if (c > 0 && Oe() && !p.densities && !globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] && (window["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] = !0, console.warn("[Needle Progressive] Detected usage of mesh without primitive densities. This might cause incorrect LOD level selection: Consider re-optimizing your model by updating your Needle Integration, Needle glTF Pipeline or running optimization again on Needle Cloud.")), S < r) {
-            L = h;
-            break;
-          }
-        }
-      L < l && (l = L, a = !0);
+      x.level >= 0 && x.level < a && (a = x.level, l = !0);
     }
-    if (a ? o.mesh_lod = l : o.mesh_lod = s.lastLodLevel_Mesh, k && o.mesh_lod != s.lastLodLevel_Mesh) {
-      const g = u?.[o.mesh_lod];
-      g && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${o.mesh_lod} (density: ${g.densities?.[c].toFixed(0)}) | ${e.name}`);
+    if (l ? n.mesh_lod = a : n.mesh_lod = s.lastLodLevel_Mesh, A && n.mesh_lod != s.lastLodLevel_Mesh) {
+      const L = u?.[n.mesh_lod];
+      L && console.log(`Mesh LOD changed: ${s.lastLodLevel_Mesh} → ${n.mesh_lod} (density: ${L.densities?.[f].toFixed(0)}) | ${e.name}`);
     }
-    if (_) {
-      const d = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
+    if (p) {
+      const x = "saveData" in globalThis.navigator && globalThis.navigator.saveData === !0;
       if (s.lastLodLevel_Texture < 0) {
-        if (o.texture_lod = w.max_count - 1, k) {
-          const g = w.lods[w.max_count - 1];
-          k && console.log(`First Texture LOD ${o.texture_lod} (${g.max_height}px) - ${e.name}`);
+        if (n.texture_lod = d.max_count - 1, A) {
+          const L = d.lods[d.max_count - 1];
+          A && console.log(`First Texture LOD ${n.texture_lod} (${L.max_height}px) - ${e.name}`);
         }
       } else {
-        const g = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
-        let b = s.lastScreenCoverage * 4;
-        this.context?.engine === "model-viewer" && (b *= 1.5);
-        const D = R / window.devicePixelRatio * b;
-        let q = !1;
-        for (let T = w.lods.length - 1; T >= 0; T--) {
-          const L = w.lods[T];
-          if (!(d && L.max_height >= 2048) && !(ve() && L.max_height > 4096) && (L.max_height > D || !q && T === 0)) {
-            if (q = !0, o.texture_lod = T, k && o.texture_lod < s.lastLodLevel_Texture) {
-              const x = L.max_height;
-              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${o.texture_lod} = ${x}px 
-Screensize: ${D.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${g.toFixed(1)} 
+        const L = s.lastScreenspaceVolume.x + s.lastScreenspaceVolume.y + s.lastScreenspaceVolume.z;
+        let w = s.lastScreenCoverage * 4;
+        this.context?.engine === "model-viewer" && (w *= 1.5);
+        const z = this.renderer.getPixelRatio?.() || globalThis.devicePixelRatio || 1, T = b / z * w;
+        let O = !1;
+        for (let P = d.lods.length - 1; P >= 0; P--) {
+          const S = d.lods[P];
+          if (!(x && S.max_height >= 2048) && !(Me() && S.max_height > 4096) && (S.max_height > T || !O && P === 0)) {
+            if (O = !0, n.texture_lod = P, A && n.texture_lod < s.lastLodLevel_Texture) {
+              const _ = S.max_height;
+              console.log(`Texture LOD changed: ${s.lastLodLevel_Texture} → ${n.texture_lod} = ${_}px 
+Screensize: ${T.toFixed(0)}px, Coverage: ${(100 * s.lastScreenCoverage).toFixed(2)}%, Volume ${L.toFixed(1)} 
 ${e.name}`);
             }
             break;
@@ -1374,62 +1712,77 @@ ${e.name}`);
         }
       }
     } else
-      o.texture_lod = 0;
+      n.texture_lod = 0;
   }
 }
-class Tt {
+class zt {
   frames = 0;
   lastLodLevel_Mesh = -1;
   lastLodLevel_Texture = -1;
   lastScreenCoverage = 0;
-  lastScreenspaceVolume = new A();
+  lastScreenspaceVolume = new k();
   lastCentrality = 0;
 }
-const Se = /* @__PURE__ */ Symbol("NEEDLE_mesh_lod"), oe = /* @__PURE__ */ Symbol("NEEDLE_texture_lod");
-let he = null;
-function Be() {
-  const i = Pt();
+function ze(i, t) {
+  if (!(t < 0)) {
+    if (Array.isArray(i)) {
+      for (const e of i)
+        ze(e, t);
+      return;
+    }
+    "color" in i && i.color instanceof Ie && (i.color.copy(Et(t, $t)), i.needsUpdate = !0);
+  }
+}
+function Et(i, t) {
+  const e = Math.max(0, Math.min(Se.length - 1, Math.floor(i)));
+  return t.setHex(Se[e]);
+}
+const Pe = /* @__PURE__ */ Symbol("NEEDLE_mesh_lod"), ae = /* @__PURE__ */ Symbol("NEEDLE_texture_lod");
+let me = null;
+function Ee() {
+  const i = Nt();
   i && (i.mapURLs(function(t) {
-    return Te(), t;
-  }), Te(), he?.disconnect(), he = new MutationObserver((t) => {
+    return Ce(), t;
+  }), Ce(), me?.disconnect(), me = new MutationObserver((t) => {
     t.forEach((e) => {
       e.addedNodes.forEach((s) => {
-        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && Ge(s);
+        s instanceof HTMLElement && s.tagName.toLowerCase() === "model-viewer" && Ne(s);
       });
     });
-  }), he.observe(document, { childList: !0, subtree: !0 }));
+  }), me.observe(document, { childList: !0, subtree: !0 }));
 }
-function Pt() {
+function Nt() {
   if (typeof customElements > "u") return null;
   const i = customElements.get("model-viewer");
   return i || (customElements.whenDefined("model-viewer").then(() => {
-    console.debug("[gltf-progressive] model-viewer defined"), Be();
+    console.debug("[gltf-progressive] model-viewer defined"), Ee();
   }), null);
 }
-function Te() {
+function Ce() {
   if (typeof document > "u") return;
   document.querySelectorAll("model-viewer").forEach((t) => {
-    Ge(t);
+    Ne(t);
   });
 }
-const Pe = /* @__PURE__ */ new WeakSet();
-let Ct = 0;
-function Ge(i) {
-  if (!i || Pe.has(i))
+const ke = /* @__PURE__ */ new WeakSet();
+let Vt = 0;
+function Ne(i) {
+  if (!i || ke.has(i))
     return null;
-  Pe.add(i), console.debug("[gltf-progressive] found new model-viewer..." + ++Ct + `
+  ke.add(i), console.debug("[gltf-progressive] found new model-viewer..." + ++Vt + `
 `, i.getAttribute("src"));
   let t = null, e = null, s = null;
   for (let r = i; r != null; r = Object.getPrototypeOf(r)) {
-    const o = Object.getOwnPropertySymbols(r), n = o.find((u) => u.toString() == "Symbol(renderer)"), l = o.find((u) => u.toString() == "Symbol(scene)"), a = o.find((u) => u.toString() == "Symbol(needsRender)");
-    !t && n != null && (t = i[n].threeRenderer), !e && l != null && (e = i[l]), !s && a != null && (s = i[a]);
+    const n = Object.getOwnPropertySymbols(r), o = n.find((u) => u.toString() == "Symbol(renderer)"), a = n.find((u) => u.toString() == "Symbol(scene)"), l = n.find((u) => u.toString() == "Symbol(needsRender)");
+    !t && o != null && (t = i[o].threeRenderer), !e && a != null && (e = i[a]), !s && l != null && (s = i[l]);
   }
   if (t && e) {
     let r = function() {
       if (s) {
-        let n = 0, l = setInterval(() => {
-          if (n++ > 5) {
-            clearInterval(l);
+        let o = 0;
+        const a = setInterval(() => {
+          if (o++ > 5) {
+            clearInterval(a);
             return;
           }
           s?.call(i);
@@ -1437,20 +1790,20 @@ function Ge(i) {
       }
     };
     console.debug("[gltf-progressive] setup model-viewer");
-    const o = v.get(t, { engine: "model-viewer" });
-    return v.addPlugin(new At()), o.enable(), o.addEventListener("changed", () => {
+    const n = I.get(t, { engine: "model-viewer" });
+    return I.addPlugin(new Xt()), n.enable(), n.addEventListener("changed", () => {
       s?.call(i);
-    }), i.addEventListener("model-visibility", (n) => {
-      n.detail.visible && s?.call(i);
+    }), i.addEventListener("model-visibility", (o) => {
+      o.detail.visible && s?.call(i);
     }), i.addEventListener("load", () => {
       r();
     }), () => {
-      o.disable();
+      n.disable();
     };
   }
   return null;
 }
-class At {
+class Xt {
   _didWarnAboutMissingUrl = !1;
   onBeforeUpdateLOD(t, e, s, r) {
     this.tryParseMeshLOD(e, r), this.tryParseTextureLOD(e, r);
@@ -1468,50 +1821,50 @@ class At {
     return t.element;
   }
   tryParseTextureLOD(t, e) {
-    if (e[oe] == !0) return;
-    e[oe] = !0;
-    const s = this.tryGetCurrentGLTF(t), r = this.tryGetCurrentModelViewer(t), o = this.getUrl(r);
-    if (o && s && e.material) {
-      let n = function(a) {
-        if (a[oe] == !0) return;
-        a[oe] = !0, a.userData && (a.userData.LOD = -1);
-        const u = Object.keys(a);
-        for (let c = 0; c < u.length; c++) {
-          const y = u[c], w = a[y];
-          if (w?.isTexture === !0) {
-            const _ = w.userData?.associations?.textures;
-            if (_ == null) continue;
-            const R = s.parser.json.textures[_];
-            if (!R) {
-              console.warn("Texture data not found for texture index " + _);
+    if (e[ae] == !0) return;
+    e[ae] = !0;
+    const s = this.tryGetCurrentGLTF(t), r = this.tryGetCurrentModelViewer(t), n = this.getUrl(r);
+    if (n && s && e.material) {
+      let o = function(l) {
+        if (l[ae] == !0) return;
+        l[ae] = !0, l.userData && (l.userData.LOD = -1);
+        const u = Object.keys(l);
+        for (let f = 0; f < u.length; f++) {
+          const c = u[f], d = l[c];
+          if (d?.isTexture === !0) {
+            const p = d.userData?.associations?.textures;
+            if (p == null) continue;
+            const b = s.parser.json.textures[p];
+            if (!b) {
+              console.warn("Texture data not found for texture index " + p);
               continue;
             }
-            if (R?.extensions?.[W]) {
-              const M = R.extensions[W];
-              M && o && m.registerTexture(o, w, M.lods.length, _, M);
+            if (b?.extensions?.[U]) {
+              const y = b.extensions[U];
+              y && n && g.registerTexture(n, d, y.lods.length, p, y);
             }
           }
         }
       };
-      const l = e.material;
-      if (Array.isArray(l)) for (const a of l) n(a);
-      else n(l);
+      const a = e.material;
+      if (Array.isArray(a)) for (const l of a) o(l);
+      else o(a);
     }
   }
   tryParseMeshLOD(t, e) {
-    if (e[Se] == !0) return;
-    e[Se] = !0;
+    if (e[Pe] == !0) return;
+    e[Pe] = !0;
     const s = this.tryGetCurrentModelViewer(t), r = this.getUrl(s);
     if (!r)
       return;
-    const o = e.userData?.gltfExtensions?.[W];
-    if (o && r) {
-      const n = e.uuid;
-      m.registerMesh(r, n, e, 0, o.lods.length, o);
+    const n = e.userData?.gltfExtensions?.[U];
+    if (n && r) {
+      const o = e.uuid;
+      g.registerMesh(r, o, e, 0, n.lods.length, n);
     }
   }
 }
-function Rt(...i) {
+function jt(...i) {
   let t, e, s, r;
   switch (i.length) {
     case 2:
@@ -1526,22 +1879,22 @@ function Rt(...i) {
     default:
       throw new Error("Invalid arguments");
   }
-  Le(e), Re(s), Ie(s, {
+  _e(e), Ge(s), We(s, {
     progressive: !0,
     ...r?.hints
-  }), s.register((n) => new m(n));
-  const o = v.get(e);
-  return r?.enableLODsManager !== !1 && o.enable(), o;
+  }), s.register((o) => new g(o));
+  const n = I.get(e);
+  return r?.enableLODsManager !== !1 && n.enable(), n;
 }
-Be();
-if (!yt) {
+Ee();
+if (!_t) {
   const i = {
     gltfProgressive: {
-      useNeedleProgressive: Rt,
-      LODsManager: v,
-      configureLoader: Ie,
-      getRaycastMesh: ee,
-      useRaycastMeshes: wt
+      useNeedleProgressive: jt,
+      LODsManager: I,
+      configureLoader: We,
+      getRaycastMesh: ne,
+      useRaycastMeshes: bt
     }
   };
   if (!globalThis.Needle)
@@ -1551,18 +1904,21 @@ if (!yt) {
       globalThis.Needle[t] = i[t];
 }
 export {
-  W as EXTENSION_NAME,
-  v as LODsManager,
-  m as NEEDLE_progressive,
-  ot as VERSION,
-  Re as addDracoAndKTX2Loaders,
-  Ie as configureLoader,
-  Le as createLoaders,
-  ee as getRaycastMesh,
-  Be as patchModelViewer,
-  xt as registerRaycastMesh,
-  lt as setDracoDecoderLocation,
-  ut as setKTX2TranscoderLocation,
-  Rt as useNeedleProgressive,
-  wt as useRaycastMeshes
+  U as EXTENSION_NAME,
+  I as LODsManager,
+  g as NEEDLE_progressive,
+  ut as VERSION,
+  Ge as addDracoAndKTX2Loaders,
+  Ut as calculateMeshLODLevel,
+  We as configureLoader,
+  _e as createLoaders,
+  Et as getLODColor,
+  ne as getRaycastMesh,
+  Se as lodDebugColors,
+  Ee as patchModelViewer,
+  Mt as registerRaycastMesh,
+  ht as setDracoDecoderLocation,
+  gt as setKTX2TranscoderLocation,
+  jt as useNeedleProgressive,
+  bt as useRaycastMeshes
 };