@voluma/vlam 0.3.2 → 0.4.0

package/dist/{splat-mesh-CsLOQb08.js → splat-mesh-B1KlWHvx.js}

@@ -1,18 +1,18 @@
 var pt = Object.defineProperty;
-var ft = (g, u, e) => u in g ? pt(g, u, { enumerable: !0, configurable: !0, writable: !0, value: e }) : g[u] = e;
-var o = (g, u, e) => ft(g, typeof u != "symbol" ? u + "" : u, e);
+var ft = (g, u, t) => u in g ? pt(g, u, { enumerable: !0, configurable: !0, writable: !0, value: t }) : g[u] = t;
+var o = (g, u, t) => ft(g, typeof u != "symbol" ? u + "" : u, t);
 import { r as Y, M as gt, a as mt } from "./splat-mesh-types-BZIko-_9.js";
 import * as d from "three/webgpu";
 import { uniform as b } from "three/tsl";
-import { z as wt, e as xt, m as St, b as vt, D as yt, c as Rt, A as Z, B as bt, E as Tt, W as At, F as K, G as Q, H as J, I as Mt, i as It, j as kt, y as Pt, n as Ct, r as Ut, J as z, C as tt, f as Dt } from "./relighting-Tiwep8yd.js";
+import { A as wt, f as xt, n as St, c as vt, D as yt, d as Rt, B as Z, E as bt, F as Tt, W as At, G as K, H as Q, I as J, J as Mt, j as It, k as kt, z as Pt, o as Ct, r as Ut, K as q, L as Dt, C as tt, g as Bt } from "./relighting-qaANKC4Z.js";
 import { l as et, w as O } from "./logging-BfPdd7NJ.js";
-import { d as Bt } from "./splat-budget-DuVZspPQ.js";
+import { d as Et } from "./splat-budget-DuVZspPQ.js";
 import { e as G } from "./half-float-Cs4FDq8Q.js";
-import { a as Et, r as Wt, n as Lt } from "./sh-pack-D5wAe5gg.js";
-function Ft() {
+import { a as Wt, r as Lt, n as Ft } from "./sh-pack-D5wAe5gg.js";
+function Vt() {
   return new d.Matrix4().makeRotationX(Math.PI);
 }
-function Vt(g) {
+function _t(g) {
   switch (g) {
     case "ply":
     case "splat":
@@ -20,7 +20,7 @@ function Vt(g) {
     case "sog":
     case "rad":
     case "streamed-sog":
-      return Ft();
+      return Vt();
     case "spz":
     case "lcc":
     case "lcc2":
@@ -28,78 +28,82 @@ function Vt(g) {
       return null;
   }
 }
-const lt = `let w = new Float32Array(0), x = new Float32Array(0);
-const f = new Uint32Array(65536);
-let E = 0, S = new Uint32Array(0), M = new Float32Array(0), I = new Uint32Array(0), R = new Uint32Array(0), Y = new Uint32Array(0);
-function j(e) {
-  e <= E || (E = e, S = new Uint32Array(e), M = new Float32Array(e), I = new Uint32Array(e), R = new Uint32Array(e), Y = new Uint32Array(e));
+const lt = `let h = new Float32Array(0), R = new Float32Array(0);
+const a = new Uint32Array(65536);
+let k = 0, Y = new Uint32Array(0), b = new Float32Array(0), I = new Uint32Array(0), E = new Uint32Array(0), K = new Uint32Array(0);
+function W(n) {
+  n <= k || (k = n, Y = new Uint32Array(n), b = new Float32Array(n), I = new Uint32Array(n), E = new Uint32Array(n), K = new Uint32Array(n));
 }
-function q(e, r, n) {
-  const D = e[2], K = e[6], _ = e[10], k = e[14];
-  let c = 0;
-  for (let t = 0; t < r.length; t += 2) c += r[t + 1];
-  j(c);
-  let d = 1 / 0, F = -1 / 0, X = 0;
+function $(n, r, o, D) {
+  const z = n[0], B = n[4], T = n[8], j = n[12], q = n[1], G = n[5], H = n[9], J = n[13], L = n[2], N = n[6], O = n[10], P = n[14];
+  let l = 0;
+  for (let t = 0; t < r.length; t += 2) l += r[t + 1];
+  W(l);
+  let p = 1 / 0, F = -1 / 0, X = 0;
   for (let t = 0; t < r.length; t += 2) {
-    const i = r[t], o = i + r[t + 1];
-    for (let s = i; s < o; s++) {
-      const a = s * 4, h = x[s], l = n ? h * 16 : 0, u = w[a], U = w[a + 1], g = w[a + 2], B = n ? n[l] * u + n[l + 4] * U + n[l + 8] * g + n[l + 12] : u, T = n ? n[l + 1] * u + n[l + 5] * U + n[l + 9] * g + n[l + 13] : U, Z = n ? n[l + 2] * u + n[l + 6] * U + n[l + 10] * g + n[l + 14] : g, A = D * B + K * T + _ * Z + k;
-      S[X] = s, M[X] = A, X++, A < d && (d = A), A > F && (F = A);
+    const A = r[t], s = A + r[t + 1];
+    for (let e = A; e < s; e++) {
+      const f = e * 4, d = R[e], c = o ? d * 16 : 0, u = h[f], U = h[f + 1], g = h[f + 2], M = o ? o[c] * u + o[c + 4] * U + o[c + 8] * g + o[c + 12] : u, x = o ? o[c + 1] * u + o[c + 5] * U + o[c + 9] * g + o[c + 13] : U, S = o ? o[c + 2] * u + o[c + 6] * U + o[c + 10] * g + o[c + 14] : g, _ = L * M + N * x + O * S + P, i = D === "radial" ? -Math.hypot(
+        z * M + B * x + T * S + j,
+        q * M + G * x + H * S + J,
+        _
+      ) : _;
+      Y[X] = e, b[X] = i, X++, i < p && (p = i), i > F && (F = i);
     }
   }
-  const z = 16777215 / (F - d || 1);
-  let y = R;
-  for (let t = 0; t < c; t++)
-    I[t] = (M[t] - d) * z, y[t] = t;
-  let p = Y;
+  const Q = 16777215 / (F - p || 1);
+  let y = E;
+  for (let t = 0; t < l; t++)
+    I[t] = (b[t] - p) * Q, y[t] = t;
+  let w = K;
   for (let t = 0; t < 24; t += 16) {
-    f.fill(0);
-    for (let o = 0; o < c; o++) {
-      const s = I[y[o]] >>> t & 65535;
-      f[s] = f[s] + 1;
+    a.fill(0);
+    for (let s = 0; s < l; s++) {
+      const e = I[y[s]] >>> t & 65535;
+      a[e] = a[e] + 1;
     }
-    let i = 0;
-    for (let o = 0; o < 65536; o++) {
-      const s = f[o];
-      f[o] = i, i += s;
+    let A = 0;
+    for (let s = 0; s < 65536; s++) {
+      const e = a[s];
+      a[s] = A, A += e;
     }
-    for (let o = 0; o < c; o++) {
-      const s = y[o], a = I[s] >>> t & 65535, h = f[a];
-      p[h] = s, f[a] = h + 1;
+    for (let s = 0; s < l; s++) {
+      const e = y[s], f = I[e] >>> t & 65535, d = a[f];
+      w[d] = e, a[f] = d + 1;
     }
-    [y, p] = [p, y];
+    [y, w] = [w, y];
   }
-  R = y, Y = p;
-  const b = new Uint32Array(c);
-  for (let t = 0; t < c; t++) b[t] = S[y[t]];
-  return b;
+  E = y, K = w;
+  const Z = new Uint32Array(l);
+  for (let t = 0; t < l; t++) Z[t] = Y[y[t]];
+  return Z;
 }
-self.onmessage = (e) => {
-  const r = e.data;
+self.onmessage = (n) => {
+  const r = n.data;
   if (r.type === "init") {
-    w = new Float32Array(r.capacity * 4), x = new Float32Array(r.capacity);
+    h = new Float32Array(r.capacity * 4), R = new Float32Array(r.capacity);
     return;
   }
   if (r.type === "write") {
-    w.set(r.centers, r.start * 4), r.sourceIds && x.set(r.sourceIds, r.start);
+    h.set(r.centers, r.start * 4), r.sourceIds && R.set(r.sourceIds, r.start);
     return;
   }
-  const n = q(r.modelView, r.spans, r.matrices), D = { type: "order", order: n };
-  self.postMessage(D, [n.buffer]);
+  const o = $(r.modelView, r.spans, r.matrices, r.sortMetric), D = { type: "order", order: o };
+  self.postMessage(D, [o.buffer]);
 };
-//# sourceMappingURL=sort-worker-CDRn-GLW.js.map
+//# sourceMappingURL=sort-worker-MzY_zfJ3.js.map
 `, it = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", lt], { type: "text/javascript;charset=utf-8" });
-function _t(g) {
+function zt(g) {
   let u;
   try {
     if (u = it && (self.URL || self.webkitURL).createObjectURL(it), !u) throw "";
-    const e = new Worker(u, {
+    const t = new Worker(u, {
       type: "module",
       name: g == null ? void 0 : g.name
     });
-    return e.addEventListener("error", () => {
+    return t.addEventListener("error", () => {
       (self.URL || self.webkitURL).revokeObjectURL(u);
-    }), e;
+    }), t;
   } catch {
     return new Worker(
       "data:text/javascript;charset=utf-8," + encodeURIComponent(lt),
@@ -111,11 +115,12 @@ function _t(g) {
   }
 }
 class qt {
-  constructor(u) {
+  constructor(u, t = "depth") {
     o(this, "kind", "worker");
     o(this, "worker");
     o(this, "splatIndexAttribute");
     o(this, "host");
+    o(this, "sortMetric");
     o(this, "inFlight", !1);
     /** Set by {@link dispose}; drops any already-delivered order message. */
     o(this, "disposed", !1);
@@ -126,23 +131,24 @@ class qt {
     o(this, "lastSubmittedAt", -1 / 0);
     o(this, "lastCompletedAt", -1 / 0);
     o(this, "lastLatencyMs", Number.NaN);
-    this.host = u, this.splatIndexAttribute = u.splatIndexAttribute, this.worker = new _t(), this.worker.onmessage = (t) => {
-      this.applyOrder(t.data.order);
-    }, this.worker.onerror = (t) => {
-      et("sort worker error - retrying on a later frame.", t.message), this.inFlight = !1;
+    this.host = u, this.sortMetric = t, this.splatIndexAttribute = u.splatIndexAttribute, this.worker = new zt(), this.worker.onmessage = (i) => {
+      this.applyOrder(i.data.order);
+    }, this.worker.onerror = (i) => {
+      et("sort worker error - retrying on a later frame.", i.message), this.inFlight = !1;
     }, this.worker.onmessageerror = () => {
       et("sort worker message deserialization failed."), this.inFlight = !1;
     };
     const e = { type: "init", capacity: u.capacity };
     this.worker.postMessage(e), this.pushCenters([{ start: 0, count: Math.ceil(u.capacity / u.rowWidth) }]);
   }
-  sort(u, e, t) {
+  sort(u, t, e) {
     if (this.disposed || this.inFlight) return !1;
     this.inFlight = !0, this.submittedCount++, this.lastSubmittedAt = performance.now(), this.pushCenters(this.host.takeDirtyRows());
     const i = this.host.getActiveSpans();
     this.sentSpans = i;
     const s = {
       type: "sort",
+      sortMetric: this.sortMetric,
       modelView: new Float32Array(u.elements),
       spans: i,
       matrices: this.host.perSource ? new Float32Array(this.host.perSource.matrices) : void 0
@@ -164,42 +170,42 @@ class qt {
   }
   /** Sends written pool rows to keep the worker's centers mirror current. */
   pushCenters(u) {
-    var t;
-    const e = this.host.rowWidth;
+    var e;
+    const t = this.host.rowWidth;
     for (const i of u) {
       const s = this.host.centers.slice(
-        i.start * e * 4,
-        (i.start + i.count) * e * 4
-      ), r = i.start * e, n = i.count * e, a = (t = this.host.perSource) == null ? void 0 : t.sourceIds.slice(r, r + n), c = { type: "write", start: r, centers: s, sourceIds: a };
-      this.worker.postMessage(c, [s.buffer]);
+        i.start * t * 4,
+        (i.start + i.count) * t * 4
+      ), r = i.start * t, n = i.count * t, a = (e = this.host.perSource) == null ? void 0 : e.sourceIds.slice(r, r + n), h = { type: "write", start: r, centers: s, sourceIds: a };
+      this.worker.postMessage(h, [s.buffer]);
     }
   }
   applyOrder(u) {
     var s, r;
     if (this.inFlight = !1, this.completedCount++, this.lastCompletedAt = performance.now(), this.lastLatencyMs = this.lastCompletedAt - this.lastSubmittedAt, this.disposed) return;
-    const e = this.host.getActiveSpans(), t = this.sentSpans;
-    if (this.sentSpans = null, !t || t.length !== e.length) return;
-    for (let n = 0; n < t.length; n++)
-      if (t[n] !== e[n]) return;
+    const t = this.host.getActiveSpans(), e = this.sentSpans;
+    if (this.sentSpans = null, !e || e.length !== t.length) return;
+    for (let n = 0; n < e.length; n++)
+      if (e[n] !== t[n]) return;
     const i = this.splatIndexAttribute.array;
     for (let n = 0; n < u.length; n++)
       i[n] = u[n];
     this.splatIndexAttribute.addUpdateRange(0, u.length), this.splatIndexAttribute.needsUpdate = !0, (r = (s = this.host).onOrderApplied) == null || r.call(s);
   }
 }
-const zt = (1 << 24) - 1, st = new d.Vector2(), V = new d.Raycaster(), rt = new d.Vector3();
-function Ot(g, u, e) {
-  return ((g & 255) << 16 | (u & 255) << 8 | e & 255) / zt;
+const Ot = (1 << 24) - 1, st = new d.Vector2(), V = new d.Raycaster(), rt = new d.Vector3();
+function Gt(g, u, t) {
+  return ((g & 255) << 16 | (u & 255) << 8 | t & 255) / Ot;
 }
-function Gt(g, u, e) {
-  return u + g * (e - u);
+function Ht(g, u, t) {
+  return u + g * (t - u);
 }
-function Ht(g, u, e, t, i) {
-  st.set(g, u), V.setFromCamera(st, t), rt.copy(V.ray.direction).transformDirection(t.matrixWorldInverse);
-  const s = e / -rt.z;
+function Nt(g, u, t, e, i) {
+  st.set(g, u), V.setFromCamera(st, e), rt.copy(V.ray.direction).transformDirection(e.matrixWorldInverse);
+  const s = t / -rt.z;
   return i.copy(V.ray.origin).addScaledVector(V.ray.direction, s), { point: i, distance: i.distanceTo(V.ray.origin) };
 }
-class Nt {
+class Xt {
   constructor(u) {
     /** Alpha below which a splat is transparent enough to pick through. */
     o(this, "alphaThreshold", b(0.1));
@@ -222,8 +228,8 @@ class Nt {
   get uniforms() {
     return { alphaThreshold: this.alphaThreshold, near: this.near, far: this.far };
   }
-  pick(u, e, t, i) {
-    const s = this.queue.then(() => this.run(u, e, t, i));
+  pick(u, t, e, i) {
+    const s = this.queue.then(() => this.run(u, t, e, i));
     return this.queue = s.then(
       () => {
       },
@@ -240,32 +246,32 @@ class Nt {
     this.material && (this.material.needsUpdate = !0);
   }
   dispose() {
-    var u, e;
-    (u = this.material) == null || u.dispose(), this.material = null, this.scene.clear(), this.proxy = null, (e = this.target) == null || e.dispose(), this.target = null, this.pickCamera = null;
+    var u, t;
+    (u = this.material) == null || u.dispose(), this.material = null, this.scene.clear(), this.proxy = null, (t = this.target) == null || t.dispose(), this.target = null, this.pickCamera = null;
   }
-  async run(u, e, t, i) {
+  async run(u, t, e, i) {
     if (this.host.isDisposed() || this.host.getActiveCount() === 0 || u.x < -1 || u.x > 1 || u.y < -1 || u.y > 1) return null;
-    if (wt(e))
+    if (wt(t))
       throw new Error(
         "SplatMesh.pick: an XR array camera has no single frustum to pick through. Pass one eye (renderer.xr.getCamera().cameras[i]) or a mono camera, and give `ndc` in that eye’s viewport."
       );
-    e.updateMatrixWorld(!0), this.host.updateWorldMatrix(), this.host.prepare(e, t);
+    t.updateMatrixWorld(!0), this.host.updateWorldMatrix(), this.host.prepare(t, e);
     const s = Math.max(1, Math.floor(this.host.getViewportSize().x)), r = Math.max(1, Math.floor(this.host.getViewportSize().y)), n = Math.floor((u.x * 0.5 + 0.5) * s), a = Math.floor((u.y * 0.5 + 0.5) * r);
     if (n < 0 || a < 0 || n >= s || a >= r) return null;
-    this.ensureResources(e);
-    const c = this.target, h = this.proxy, l = this.pickCamera;
-    this.cropCameraToPixel(l, e, s, r, n, a), this.host.setView(l, 1, 1);
-    const f = "near" in e && typeof e.near == "number" ? e.near : 0.1, x = "far" in e && typeof e.far == "number" ? e.far : 1e3;
+    this.ensureResources(t);
+    const h = this.target, c = this.proxy, l = this.pickCamera;
+    this.cropCameraToPixel(l, t, s, r, n, a), this.host.setView(l, 1, 1);
+    const f = "near" in t && typeof t.near == "number" ? t.near : 0.1, x = "far" in t && typeof t.far == "number" ? t.far : 1e3;
     this.near.value = f, this.far.value = x, this.alphaThreshold.value = (i == null ? void 0 : i.alphaThreshold) !== void 0 ? i.alphaThreshold : 0.1;
-    const p = this.host.mesh, w = t.getRenderTarget(), m = t.getScissorTest();
-    t.getClearColor(this.savedClearColor);
-    const S = t.getClearAlpha(), A = t.autoClear;
-    h.matrix.copy(p.matrixWorld), h.matrixWorld.copy(p.matrixWorld), h.visible = this.host.getPickVisible(), h.layers.mask = p.layers.mask, h.renderOrder = p.renderOrder, c.viewport.set(0, 0, 1, 1), c.scissor.set(0, 0, 1, 1);
+    const p = this.host.mesh, w = e.getRenderTarget(), m = e.getScissorTest();
+    e.getClearColor(this.savedClearColor);
+    const S = e.getClearAlpha(), A = e.autoClear;
+    c.matrix.copy(p.matrixWorld), c.matrixWorld.copy(p.matrixWorld), c.visible = this.host.getPickVisible(), c.layers.mask = p.layers.mask, c.renderOrder = p.renderOrder, h.viewport.set(0, 0, 1, 1), h.scissor.set(0, 0, 1, 1);
     const R = (() => {
       try {
-        return t.setRenderTarget(c), t.setScissorTest(!1), t.setClearColor(0, 0), t.autoClear = !0, t.clear(), t.setScissorTest(!0), t.autoClear = !1, t.render(this.scene, l), t.readRenderTargetPixelsAsync(c, 0, 0, 1, 1);
+        return e.setRenderTarget(h), e.setScissorTest(!1), e.setClearColor(0, 0), e.autoClear = !0, e.clear(), e.setScissorTest(!0), e.autoClear = !1, e.render(this.scene, l), e.readRenderTargetPixelsAsync(h, 0, 0, 1, 1);
       } finally {
-        this.host.setView(e, s, r), t.setRenderTarget(w), t.setScissorTest(m), t.setClearColor(this.savedClearColor, S), t.autoClear = A;
+        this.host.setView(t, s, r), e.setRenderTarget(w), e.setScissorTest(m), e.setClearColor(this.savedClearColor, S), e.autoClear = A;
       }
     })();
     let y;
@@ -278,7 +284,7 @@ class Nt {
     if (this.host.isDisposed()) return null;
     const M = y[0], U = y[1], I = y[2];
     if (y[3] === 0) return null;
-    const B = Gt(Ot(M, U, I), f, x), { point: E, distance: W } = Ht(u.x, u.y, B, e, this.point);
+    const B = Ht(Gt(M, U, I), f, x), { point: E, distance: W } = Nt(u.x, u.y, B, t, this.point);
     return { point: E.clone(), distance: W };
   }
   ensureResources(u) {
@@ -290,24 +296,24 @@ class Nt {
     })), this.material === null && (this.material = new d.NodeMaterial(), this.host.applyPickGraph(this.material), this.proxy = new d.Mesh(this.host.mesh.geometry, this.material), this.proxy.matrixAutoUpdate = !1, this.proxy.frustumCulled = !1, this.scene.add(this.proxy)), (this.pickCamera === null || this.pickCamera.constructor !== u.constructor) && (this.pickCamera = u.clone());
   }
   /** Maps one original framebuffer pixel onto the complete 1×1 pick target. */
-  cropCameraToPixel(u, e, t, i, s, r) {
-    u.copy(e);
-    const n = u.projectionMatrix, a = n.elements, c = 2 * s + 1 - t, h = 2 * r + 1 - i;
+  cropCameraToPixel(u, t, e, i, s, r) {
+    u.copy(t);
+    const n = u.projectionMatrix, a = n.elements, h = 2 * s + 1 - e, c = 2 * r + 1 - i;
     for (let l = 0; l < 4; l++) {
       const f = a[l * 4 + 3];
-      a[l * 4] = a[l * 4] * t - c * f, a[l * 4 + 1] = a[l * 4 + 1] * i - h * f;
+      a[l * 4] = a[l * 4] * e - h * f, a[l * 4 + 1] = a[l * 4 + 1] * i - c * f;
     }
     u.projectionMatrixInverse.copy(n).invert();
   }
 }
-const Xt = 1024, jt = 1 << 21;
-class $t {
+const jt = 1024, $t = 1 << 21;
+class Yt {
   /**
    * @param centers - The pool's CPU centers (stride 4: x,y,z,_ per splat).
    * @param poolIndices - The pool indices to index (e.g. the active list).
    * @param count - How many entries of `poolIndices` are valid.
    */
-  constructor(u, e, t) {
+  constructor(u, t, e) {
     /** Populated-region minimum corner (local space). */
     o(this, "min", new Float64Array(3));
     /** Per-axis cell size (local units). */
@@ -321,13 +327,13 @@ class $t {
     /** Pool centers array this grid points into (RGBA stride 4). */
     o(this, "centers");
     o(this, "count");
-    if (this.centers = u, this.count = t, t === 0) {
+    if (this.centers = u, this.count = e, e === 0) {
       this.dims.set([1, 1, 1]), this.cellSize.set([1, 1, 1]), this.cellStart = new Int32Array(2), this.items = new Uint32Array(0);
       return;
     }
     const i = [1 / 0, 1 / 0, 1 / 0], s = [-1 / 0, -1 / 0, -1 / 0];
-    for (let p = 0; p < t; p++) {
-      const w = e[p] * 4;
+    for (let p = 0; p < e; p++) {
+      const w = t[p] * 4;
       for (let m = 0; m < 3; m++) {
         const S = u[w + m];
         S < i[m] && (i[m] = S), S > s[m] && (s[m] = S);
@@ -338,34 +344,34 @@ class $t {
       s[1] - i[1],
       s[2] - i[2]
     ], n = r.filter((p) => p > 0), a = n.reduce((p, w) => p * w, 1);
-    let c = n.length > 0 ? Math.pow(a / t, 1 / n.length) : 1;
-    (!(c > 0) || !Number.isFinite(c)) && (c = 1);
-    const h = (p) => {
+    let h = n.length > 0 ? Math.pow(a / e, 1 / n.length) : 1;
+    (!(h > 0) || !Number.isFinite(h)) && (h = 1);
+    const c = (p) => {
       for (let w = 0; w < 3; w++) {
         const m = r[w];
-        this.dims[w] = m > 0 ? Math.max(1, Math.min(Xt, Math.round(m / p) || 1)) : 1, this.cellSize[w] = this.dims[w] > 0 && m / this.dims[w] || 1, this.min[w] = i[w];
+        this.dims[w] = m > 0 ? Math.max(1, Math.min(jt, Math.round(m / p) || 1)) : 1, this.cellSize[w] = this.dims[w] > 0 && m / this.dims[w] || 1, this.min[w] = i[w];
       }
     };
-    for (h(c); this.dims[0] * this.dims[1] * this.dims[2] > jt; )
-      c *= 1.5, h(c);
+    for (c(h); this.dims[0] * this.dims[1] * this.dims[2] > $t; )
+      h *= 1.5, c(h);
     const l = this.dims[0] * this.dims[1] * this.dims[2], f = new Int32Array(l + 1);
-    for (let p = 0; p < t; p++) f[this.cellOf(e[p]) + 1]++;
+    for (let p = 0; p < e; p++) f[this.cellOf(t[p]) + 1]++;
     for (let p = 0; p < l; p++) f[p + 1] += f[p];
-    this.cellStart = f, this.items = new Uint32Array(t);
+    this.cellStart = f, this.items = new Uint32Array(e);
     const x = Int32Array.from(f.subarray(0, l));
-    for (let p = 0; p < t; p++) {
-      const w = e[p];
+    for (let p = 0; p < e; p++) {
+      const w = t[p];
       this.items[x[this.cellOf(w)]++] = w;
     }
   }
   /** The cell index of pool splat `p`, clamped into range. */
   cellOf(u) {
-    const e = u * 4, t = this.axisCell(0, this.centers[e]), i = this.axisCell(1, this.centers[e + 1]);
-    return (this.axisCell(2, this.centers[e + 2]) * this.dims[1] + i) * this.dims[0] + t;
+    const t = u * 4, e = this.axisCell(0, this.centers[t]), i = this.axisCell(1, this.centers[t + 1]);
+    return (this.axisCell(2, this.centers[t + 2]) * this.dims[1] + i) * this.dims[0] + e;
   }
-  axisCell(u, e) {
-    const t = Math.floor((e - this.min[u]) / this.cellSize[u]);
-    return Math.max(0, Math.min(this.dims[u] - 1, t));
+  axisCell(u, t) {
+    const e = Math.floor((t - this.min[u]) / this.cellSize[u]);
+    return Math.max(0, Math.min(this.dims[u] - 1, e));
   }
   /**
    * Visits every indexed splat within `radius` (local units) of the local
@@ -373,18 +379,18 @@ class $t {
    * axis span and each candidate is distance-filtered here, so the callback
    * only ever sees splats truly within the radius.
    */
-  forEachWithin(u, e, t, i, s) {
+  forEachWithin(u, t, e, i, s) {
     if (this.count === 0 || i < 0) return;
-    const r = i * i, n = [0, 0, 0], a = [0, 0, 0], c = [u, e, t];
-    for (let h = 0; h < 3; h++) {
-      const l = Math.ceil(i / this.cellSize[h]), f = this.axisCell(h, c[h]);
-      n[h] = Math.max(0, f - l), a[h] = Math.min(this.dims[h] - 1, f + l);
+    const r = i * i, n = [0, 0, 0], a = [0, 0, 0], h = [u, t, e];
+    for (let c = 0; c < 3; c++) {
+      const l = Math.ceil(i / this.cellSize[c]), f = this.axisCell(c, h[c]);
+      n[c] = Math.max(0, f - l), a[c] = Math.min(this.dims[c] - 1, f + l);
     }
-    for (let h = n[2]; h <= a[2]; h++)
+    for (let c = n[2]; c <= a[2]; c++)
       for (let l = n[1]; l <= a[1]; l++) {
-        const f = (h * this.dims[1] + l) * this.dims[0], x = this.cellStart[f + n[0]], p = this.cellStart[f + a[0] + 1];
+        const f = (c * this.dims[1] + l) * this.dims[0], x = this.cellStart[f + n[0]], p = this.cellStart[f + a[0] + 1];
         for (let w = x; w < p; w++) {
-          const m = this.items[w], S = m * 4, A = this.centers[S] - u, R = this.centers[S + 1] - e, y = this.centers[S + 2] - t, M = A * A + R * R + y * y;
+          const m = this.items[w], S = m * 4, A = this.centers[S] - u, R = this.centers[S + 1] - t, y = this.centers[S + 2] - e, M = A * A + R * R + y * y;
           M <= r && s(m, M);
         }
       }
@@ -393,35 +399,35 @@ class $t {
    * The nearest indexed splat to the local point within `radius`, or null.
    * Returns its pool index and squared local distance.
    */
-  nearest(u, e, t, i) {
+  nearest(u, t, e, i) {
     let s = -1, r = 1 / 0;
-    return this.forEachWithin(u, e, t, i, (n, a) => {
+    return this.forEachWithin(u, t, e, i, (n, a) => {
       a < r && (r = a, s = n);
     }), s < 0 ? null : { poolIndex: s, distSq: r };
   }
 }
-const Yt = 4, v = class v extends d.Mesh {
-  constructor(e, t = {}) {
+const Zt = 4, v = class v extends d.Mesh {
+  constructor(t, e = {}) {
     var W, L;
-    const i = bt(t.sortIntervalMs), s = ((W = Bt()) == null ? void 0 : W.isMobile) === !0, r = ct(t.maxStdDev) ?? 3, n = Jt(t.minSplatSizePx) ?? (s ? 1.5 : 0), a = !("capacity" in e), c = a ? e.count : e.capacity;
-    if (c <= 0) throw new Error("SplatMesh capacity must be positive.");
-    const h = (t.shBands ?? (Y(t.performanceProfile) === "smooth" ? 0 : gt)) !== 0, l = a ? h ? ((L = e.shPacked) == null ? void 0 : L.bands) ?? 0 : 0 : t.shBands ?? 0, f = t.pool, x = () => new Dt({
-      capacity: c,
-      floatTextures: t.poolFloatTextures,
+    const i = bt(e.sortIntervalMs), s = ((W = Et()) == null ? void 0 : W.isMobile) === !0, r = ht(e.maxStdDev) ?? 3, n = te(e.minSplatSizePx) ?? (s ? 1.5 : 0), a = !("capacity" in t), h = a ? t.count : t.capacity;
+    if (h <= 0) throw new Error("SplatMesh capacity must be positive.");
+    const c = (e.shBands ?? (Y(e.performanceProfile) === "smooth" ? 0 : gt)) !== 0, l = a ? c ? ((L = t.shPacked) == null ? void 0 : L.bands) ?? 0 : 0 : e.shBands ?? 0, f = e.pool, x = () => new Bt({
+      capacity: h,
+      floatTextures: e.poolFloatTextures,
       packedShBands: l,
       packedShTextureCount: l === 0 ? 0 : Math.ceil(J(l) / 4),
-      ...t.maxTextureSize === void 0 ? {} : { maxTextureSize: t.maxTextureSize }
+      ...e.maxTextureSize === void 0 ? {} : { maxTextureSize: e.maxTextureSize }
     }), p = f !== void 0 && l !== f.packedShBands;
     p && O(
       `a mesh with shBands ${l} cannot share a pool built for ${f == null ? void 0 : f.packedShBands}; it allocated its own pool instead.`
     );
     const w = f === void 0 || p, m = w ? x() : f, S = Math.min(
       m.capacity,
-      Math.ceil(c / v.DATA_TEXTURE_WIDTH) * v.DATA_TEXTURE_WIDTH
-    ), A = m.centersTexture, R = m.colorsTexture, y = m.covarianceATexture, M = m.covarianceBTexture, U = a && e.sh && h ? Tt(
-      e.sh.palette,
-      e.sh.paletteWidth,
-      e.sh.paletteHeight,
+      Math.ceil(h / v.DATA_TEXTURE_WIDTH) * v.DATA_TEXTURE_WIDTH
+    ), A = m.centersTexture, R = m.colorsTexture, y = m.covarianceATexture, M = m.covarianceBTexture, U = a && t.sh && c ? Tt(
+      t.sh.palette,
+      t.sh.paletteWidth,
+      t.sh.paletteHeight,
       d.FloatType
     ) : null, I = m.shPackedTextures, D = new d.InstancedBufferGeometry();
     D.setIndex([0, 1, 2, 0, 2, 3]), D.setAttribute(
@@ -569,7 +575,7 @@ const Yt = 4, v = class v extends d.Mesh {
     o(this, "screenBandMin", b(0));
     o(this, "screenBandMax", b(0));
     /** The pick pass and everything it allocates; see `splat-mesh-picking.ts`. */
-    o(this, "picker", new Nt({
+    o(this, "picker", new Xt({
       mesh: this,
       isDisposed: () => this.disposed,
       getActiveCount: () => this.activeCount,
@@ -577,12 +583,12 @@ const Yt = 4, v = class v extends d.Mesh {
       getPickVisible: () => this.effectiveVisibility,
       hasSorter: () => this.sorter !== null,
       updateWorldMatrix: () => this.updateWorldMatrix(!0, !1),
-      prepare: (e, t) => {
-        this.flushPendingUploads(t), this.refreshProjectionUniforms(e, t), this.sorter !== null && this.requestSortIfNeeded(e, t);
+      prepare: (t, e) => {
+        this.flushPendingUploads(e), this.refreshProjectionUniforms(t, e), this.sorter !== null && this.requestSortIfNeeded(t, e);
       },
-      setView: (e, t, i) => this.writeViewUniforms(e, t, i),
-      applyPickGraph: (e) => Z(
-        e,
+      setView: (t, e, i) => this.writeViewUniforms(t, e, i),
+      applyPickGraph: (t) => Z(
+        t,
         "pick",
         this.graphInputs(this.materialInputs.textures, this.materialInputs.sh)
       )
@@ -595,8 +601,10 @@ const Yt = 4, v = class v extends d.Mesh {
      * storage-attribute GPU buffers that never sat in a geometry. */
     o(this, "lastRenderer", null);
     o(this, "currentModelView", new d.Matrix4());
+    /** Pose components that can actually change the selected sort key. */
+    o(this, "currentSortState", new d.Matrix4());
     /** Initialized to an impossible matrix so the first frame always sorts. */
-    o(this, "lastSortedModelView", new d.Matrix4().makeScale(0, 0, 0));
+    o(this, "lastSortedState", new d.Matrix4().makeScale(0, 0, 0));
     o(this, "sortScheduler");
     /** One-frame queue-headroom hint used before a staged atomic commit. */
     o(this, "deferSortRequestOnce", !1);
@@ -605,6 +613,7 @@ const Yt = 4, v = class v extends d.Mesh {
     /** The active list the current depth order was built from. */
     o(this, "sortedActiveListVersion", -1);
     o(this, "sortStrategy");
+    o(this, "sortMetric");
     /** Resolved only when `sortStrategy === 'radix'`; see {@link ensureRadixSorter}. */
     o(this, "RadixSorterCtor", null);
     o(this, "radixSorterLoad", null);
@@ -641,17 +650,17 @@ const Yt = 4, v = class v extends d.Mesh {
     o(this, "orientation");
     /** Set once the pool has been checked against the device texture limit. */
     o(this, "textureLimitChecked", !1);
-    if (this.pool = m, this.ownsPool = w, m.register(this), this.sortScheduler = new At(i, s), this.sortStrategy = t.sortStrategy ?? "counting", this.sortStrategy === "radix" && this.ensureRadixSorter(), this.performanceProfileValue = Y(t.performanceProfile), this.maxStdDevValue = r, this.minSplatSizePx = n, this.antialias = t.antialias ?? (a ? e.antialias ?? !1 : !1), this.projectedFilterProfile = t.projectedFilterProfile ?? "default", this.srgbOutput = t.srgbOutput ?? !1, this.maxSplatScreenRadius = H(t.maxSplatScreenRadius), this.minSplatScreenRadius = H(t.minSplatScreenRadius), this.screenBandMin.value = this.minSplatScreenRadius, this.screenBandMax.value = this.maxSplatScreenRadius, this.foveationMode = mt(t.foveationMode), this.foveationTargetPx = ee(t.foveationTargetPx), this.foveationDrawBudget = se(t.foveationDrawBudget), this.foveationLimitPx = this.foveationTargetPx, this.maxSplatAspect = H(t.maxSplatAspect), this.lodAlpha = t.lodAlpha ?? !1, this.orientation = t.orientation ?? "y-up", this.splatIndexAttribute = E, this.sourceIndexAttribute = new d.StorageBufferAttribute(new Uint32Array(S), 1), this.dataTextures = m.coreTextures, this.isStatic = a, this.shEnabled = U !== null, this.shRange = { min: K(), max: K() }, this.frustumCulled = !1, U && (this.dataTextures = [...this.dataTextures, U]), I.length > 0 && (this.dataTextures = [...this.dataTextures, ...I]), this.materialInputs = {
+    if (this.pool = m, this.ownsPool = w, m.register(this), this.sortScheduler = new At(i, s), this.sortStrategy = e.sortStrategy ?? "counting", this.sortMetric = e.sortMetric ?? "depth", (this.sortStrategy === "radix" || this.sortStrategy === "exact") && this.ensureRadixSorter(), this.performanceProfileValue = Y(e.performanceProfile), this.maxStdDevValue = r, this.minSplatSizePx = n, this.antialias = e.antialias ?? (a ? t.antialias ?? !1 : !1), this.projectedFilterProfile = e.projectedFilterProfile ?? "default", this.srgbOutput = e.srgbOutput ?? !1, this.maxSplatScreenRadius = H(e.maxSplatScreenRadius), this.minSplatScreenRadius = H(e.minSplatScreenRadius), this.screenBandMin.value = this.minSplatScreenRadius, this.screenBandMax.value = this.maxSplatScreenRadius, this.foveationMode = mt(e.foveationMode), this.foveationTargetPx = ie(e.foveationTargetPx), this.foveationDrawBudget = re(e.foveationDrawBudget), this.foveationLimitPx = this.foveationTargetPx, this.maxSplatAspect = H(e.maxSplatAspect), this.lodAlpha = e.lodAlpha ?? !1, this.orientation = e.orientation ?? "y-up", this.splatIndexAttribute = E, this.sourceIndexAttribute = new d.StorageBufferAttribute(new Uint32Array(S), 1), this.dataTextures = m.coreTextures, this.isStatic = a, this.shEnabled = U !== null, this.shRange = { min: K(), max: K() }, this.frustumCulled = !1, U && (this.dataTextures = [...this.dataTextures, U]), I.length > 0 && (this.dataTextures = [...this.dataTextures, ...I]), this.materialInputs = {
       textures: { centersTexture: A, colorsTexture: R, covarianceATexture: y, covarianceBTexture: M },
-      sh: a && e.sh && U ? { mode: "palette", bands: e.sh.bands, paletteTexture: U } : l !== 0 ? {
+      sh: a && t.sh && U ? { mode: "palette", bands: t.sh.bands, paletteTexture: U } : l !== 0 ? {
         mode: "packed",
         bands: l,
         textures: I,
         range: this.shRange
       } : null
     }, this.buildMaterial(this.materialInputs.textures, this.materialInputs.sh), a) {
-      this.staticRange = this.appendRange(e), this.pendingUploadRows = [], this.poolFloatTextures === "float16" && this.syncHalfFloatPoolImages();
-      const C = this.orientation === "y-up" ? Vt(e.format) : null;
+      this.staticRange = this.appendRange(t), this.pendingUploadRows = [], this.poolFloatTextures === "float16" && this.syncHalfFloatPoolImages();
+      const C = this.orientation === "y-up" ? _t(t.format) : null;
       C && (this.matrix.copy(C), this.matrix.decompose(this.position, this.quaternion, this.scale), this.matrixWorldNeedsUpdate = !0);
     }
   }
@@ -677,8 +686,8 @@ const Yt = 4, v = class v extends d.Mesh {
   get freeRowSpans() {
     return this.pool.freeRowSpans;
   }
-  set freeRowSpans(e) {
-    this.pool.freeRowSpans = e;
+  set freeRowSpans(t) {
+    this.pool.freeRowSpans = t;
   }
   get poolFloatTextures() {
     return this.pool.floatTextures;
@@ -697,8 +706,8 @@ const Yt = 4, v = class v extends d.Mesh {
    * asked for - useful for a debug readout.
    */
   get shBands() {
-    var e;
-    return ((e = this.materialInputs.sh) == null ? void 0 : e.bands) ?? 0;
+    var t;
+    return ((t = this.materialInputs.sh) == null ? void 0 : t.bands) ?? 0;
   }
   /**
    * The contribution-culling profile currently in effect (resolved at
@@ -716,8 +725,8 @@ const Yt = 4, v = class v extends d.Mesh {
    * material graph, {@link StreamedSplatMesh.setBudget} returns its clamp.
    * Every mutator has a matching readable property.
    */
-  setPerformanceProfile(e) {
-    e !== this.performanceProfileValue && (this.performanceProfileValue = e, this.buildMaterial(this.materialInputs.textures, this.materialInputs.sh));
+  setPerformanceProfile(t) {
+    t !== this.performanceProfileValue && (this.performanceProfileValue = t, this.buildMaterial(this.materialInputs.textures, this.materialInputs.sh));
   }
   /**
    * Gaussian cutoff radius currently in effect, in standard deviations.
@@ -733,9 +742,9 @@ const Yt = 4, v = class v extends d.Mesh {
    * view; raising it restores the faint outer tail. Rebuilds the material
    * graph, same convention as {@link setPerformanceProfile}.
    */
-  setMaxStdDev(e) {
-    const t = ct(e);
-    t === void 0 || t === this.maxStdDevValue || (this.maxStdDevValue = t, this.cachedUnifiedView = null, this.buildMaterial(this.materialInputs.textures, this.materialInputs.sh));
+  setMaxStdDev(t) {
+    const e = ht(t);
+    e === void 0 || e === this.maxStdDevValue || (this.maxStdDevValue = e, this.cachedUnifiedView = null, this.buildMaterial(this.materialInputs.textures, this.materialInputs.sh));
   }
   /**
    * Copies a decoded scene (or chunk) into the pool and activates it.
@@ -745,40 +754,40 @@ const Yt = 4, v = class v extends d.Mesh {
    * @returns A handle to pass to {@link removeRange}.
    * @throws {Error} when the remaining pool capacity cannot fit the range.
    */
-  appendRange(e) {
-    return this.appendRangeWithState(e, !0);
+  appendRange(t) {
+    return this.appendRangeWithState(t, !0);
   }
   /** Appends uploaded data without exposing it to draw/sort until activated. */
-  appendInactiveRange(e) {
-    return this.appendRangeWithState(e, !1);
+  appendInactiveRange(t) {
+    return this.appendRangeWithState(t, !1);
   }
   /** Reserves an inactive pool range whose data can be filled over multiple frames. */
-  reserveInactiveRange(e) {
-    if (!Number.isInteger(e) || e < 0)
+  reserveInactiveRange(t) {
+    if (!Number.isInteger(t) || t < 0)
       throw new RangeError("SplatMesh.reserveInactiveRange: count must be a non-negative integer.");
-    if (e === 0) {
+    if (t === 0) {
       const a = Object.freeze({ count: 0 });
       return this.ranges.set(a, { startRow: 0, rowCount: 0, start: 0, count: 0, active: !1 }), a;
     }
-    const t = v.DATA_TEXTURE_WIDTH, i = Math.ceil(e / t), s = Q(this.freeRowSpans, i, this.poolRows), r = s * t, n = Object.freeze({ count: e });
-    this.ranges.set(n, { startRow: s, rowCount: i, start: r, count: e, active: !1 });
+    const e = v.DATA_TEXTURE_WIDTH, i = Math.ceil(t / e), s = Q(this.freeRowSpans, i, this.poolRows), r = s * e, n = Object.freeze({ count: t });
+    this.ranges.set(n, { startRow: s, rowCount: i, start: r, count: t, active: !1 });
     for (const a of this.channels.values())
-      a.backing.fill(a.fill, r, r + i * t), a.pendingRows.push({ start: s, count: i });
+      a.backing.fill(a.fill, r, r + i * e), a.pendingRows.push({ start: s, count: i });
     return n;
   }
   /** Writes one contiguous segment of a reserved inactive range. */
-  writeInactiveRange(e, t, i) {
-    const s = this.ranges.get(e);
+  writeInactiveRange(t, e, i) {
+    const s = this.ranges.get(t);
     if (!s) throw new Error("SplatMesh.writeInactiveRange: unknown range handle.");
     if (s.active) throw new Error("SplatMesh.writeInactiveRange: range is already active.");
-    if (!Number.isInteger(i) || i < 0 || i + t.count > s.count)
+    if (!Number.isInteger(i) || i < 0 || i + e.count > s.count)
       throw new RangeError("SplatMesh.writeInactiveRange: write exceeds the reserved range.");
-    if (t.count === 0) return;
-    this.warnOnIgnoredSh(t, "writeInactiveRange");
+    if (e.count === 0) return;
+    this.warnOnIgnoredSh(e, "writeInactiveRange");
     const r = s.start + i;
-    this.writeSplatRows(r, t);
-    const n = v.DATA_TEXTURE_WIDTH, a = Math.floor(r / n), c = Math.floor((r + t.count - 1) / n);
-    this.markRowsWritten(a, c - a + 1), F.setFromArray(t.positions), this.localBounds.union(F), this.boundsDirty = !0;
+    this.writeSplatRows(r, e);
+    const n = v.DATA_TEXTURE_WIDTH, a = Math.floor(r / n), h = Math.floor((r + e.count - 1) / n);
+    this.markRowsWritten(a, h - a + 1), F.setFromArray(e.positions), this.localBounds.union(F), this.boundsDirty = !0;
   }
   /**
    * Overwrites splats at `offset` within a range **in place** - unlike
@@ -787,31 +796,31 @@ const Yt = 4, v = class v extends d.Mesh {
    * touched rows for upload; the caller must {@link invalidateSort} once per
    * batch since splat depths changed.
    */
-  overwriteRangeData(e, t, i) {
-    const s = this.ranges.get(e);
+  overwriteRangeData(t, e, i) {
+    const s = this.ranges.get(t);
     if (!s) throw new Error("SplatMesh.overwriteRangeData: unknown range handle.");
-    if (!Number.isInteger(i) || i < 0 || i + t.count > s.count)
+    if (!Number.isInteger(i) || i < 0 || i + e.count > s.count)
       throw new RangeError("SplatMesh.overwriteRangeData: write exceeds the range.");
-    if (t.count === 0) return;
-    this.warnOnIgnoredSh(t, "overwriteRangeData");
+    if (e.count === 0) return;
+    this.warnOnIgnoredSh(e, "overwriteRangeData");
     const r = s.start + i;
-    this.writeSplatRows(r, t);
-    const n = v.DATA_TEXTURE_WIDTH, a = Math.floor(r / n), c = Math.floor((r + t.count - 1) / n);
-    this.markRowsWritten(a, c - a + 1), F.setFromArray(t.positions), this.localBounds.union(F), this.boundsDirty = !0, this.contentRevision++;
+    this.writeSplatRows(r, e);
+    const n = v.DATA_TEXTURE_WIDTH, a = Math.floor(r / n), h = Math.floor((r + e.count - 1) / n);
+    this.markRowsWritten(a, h - a + 1), F.setFromArray(e.positions), this.localBounds.union(F), this.boundsDirty = !0, this.contentRevision++;
   }
   /**
    * Zeros splats `[offset, offset + count)` of a range so they draw nothing
    * (zero covariance → degenerate quad, zero color). Used to free frontier slab
    * slots that leave the frontier. Queues the rows for upload.
    */
-  degenerateRange(e, t, i) {
-    const s = this.ranges.get(e);
+  degenerateRange(t, e, i) {
+    const s = this.ranges.get(t);
     if (!s) throw new Error("SplatMesh.degenerateRange: unknown range handle.");
     if (i <= 0) return;
-    if (!Number.isInteger(t) || t < 0 || t + i > s.count)
+    if (!Number.isInteger(e) || e < 0 || e + i > s.count)
       throw new RangeError("SplatMesh.degenerateRange: range out of bounds.");
-    const r = s.start + t, { centers: n, colors: a, covarianceA: c, covarianceB: h } = this.backing;
-    n.fill(0, r * 4, (r + i) * 4), a.fill(0, r * 4, (r + i) * 4), c.fill(0, r * 4, (r + i) * 4), h.fill(0, r * 4, (r + i) * 4);
+    const r = s.start + e, { centers: n, colors: a, covarianceA: h, covarianceB: c } = this.backing;
+    n.fill(0, r * 4, (r + i) * 4), a.fill(0, r * 4, (r + i) * 4), h.fill(0, r * 4, (r + i) * 4), c.fill(0, r * 4, (r + i) * 4);
     const l = v.DATA_TEXTURE_WIDTH, f = Math.floor(r / l), x = Math.floor((r + i - 1) / l);
     this.markRowsWritten(f, x - f + 1), this.contentRevision++;
   }
@@ -820,15 +829,15 @@ const Yt = 4, v = class v extends d.Mesh {
    * Shared by the append and staged-write paths, which differ only in where
    * the rows come from and when they are activated.
    */
-  writeSplatRows(e, t) {
+  writeSplatRows(t, e) {
     const { centers: i, colors: s, covarianceA: r, covarianceB: n } = this.backing;
-    s.set(t.colors, e * 4);
-    const a = t.count, c = t.positions, h = t.covariances, l = this.shEnabled && t.sh ? t.sh.labels : null, f = t.frontierParent ?? null;
+    s.set(e.colors, t * 4);
+    const a = e.count, h = e.positions, c = e.covariances, l = this.shEnabled && e.sh ? e.sh.labels : null, f = e.frontierParent ?? null;
     for (let x = 0; x < a; x++) {
-      const p = (e + x) * 4, w = x * 3, m = x * 6;
-      i[p + 0] = c[w + 0], i[p + 1] = c[w + 1], i[p + 2] = c[w + 2], r[p + 0] = h[m + 0], r[p + 1] = h[m + 1], r[p + 2] = h[m + 2], r[p + 3] = h[m + 3], n[p + 0] = h[m + 4], n[p + 1] = h[m + 5], n[p + 2] = l ? l[x] : 0, n[p + 3] = f ? f[x] : 0;
+      const p = (t + x) * 4, w = x * 3, m = x * 6;
+      i[p + 0] = h[w + 0], i[p + 1] = h[w + 1], i[p + 2] = h[w + 2], r[p + 0] = c[m + 0], r[p + 1] = c[m + 1], r[p + 2] = c[m + 2], r[p + 3] = c[m + 3], n[p + 0] = c[m + 4], n[p + 1] = c[m + 5], n[p + 2] = l ? l[x] : 0, n[p + 3] = f ? f[x] : 0;
     }
-    this.writePackedSh(e, t);
+    this.writePackedSh(t, e);
   }
   /**
    * Scatters a chunk's packed SH words into the per-group pool textures.
@@ -838,24 +847,24 @@ const Yt = 4, v = class v extends d.Mesh {
    * else's view-dependent color. Zero is not neutral (the range is signed and
    * rarely symmetric), so the code for "0.0" in this scene's range is.
    */
-  writePackedSh(e, t) {
+  writePackedSh(t, e) {
     if (this.packedShBands === 0) return;
-    const i = this.backing.shPacked, s = J(this.packedShBands), r = t.shPacked;
+    const i = this.backing.shPacked, s = J(this.packedShBands), r = e.shPacked;
     if (r && r.bands === this.packedShBands) {
       this.applyShRange(r);
-      const a = this.currentShRange(), c = a !== null && !Et(r.range, a);
-      for (let h = 0; h < t.count; h++)
+      const a = this.currentShRange(), h = a !== null && !Wt(r.range, a);
+      for (let c = 0; c < e.count; c++)
         for (let l = 0; l < s; l++) {
-          const f = r.packed[h * s + l];
-          i[l >> 2][(e + h) * 4 + (l & 3)] = c ? Wt(f, r.range, a) : f;
+          const f = r.packed[c * s + l];
+          i[l >> 2][(t + c) * 4 + (l & 3)] = h ? Lt(f, r.range, a) : f;
         }
       return;
     }
     this.shRangeSet || (this.wrotePreLockNeutralSh = !0);
     const n = this.neutralShWord();
-    for (let a = 0; a < t.count; a++)
-      for (let c = 0; c < s; c++)
-        i[c >> 2][(e + a) * 4 + (c & 3)] = n;
+    for (let a = 0; a < e.count; a++)
+      for (let h = 0; h < s; h++)
+        i[h >> 2][(t + a) * 4 + (h & 3)] = n;
   }
   /**
    * Adopts the first packed-SH chunk's dequantization range as the scene's one
@@ -863,40 +872,40 @@ const Yt = 4, v = class v extends d.Mesh {
    * chunk measures its own extent, so later chunks are requantized into this
    * one at write time ({@link writePackedSh}) rather than ignored.
    */
-  applyShRange(e) {
-    if (!this.shRangeSet && (this.shRange.min.value.set(e.range.min[0], e.range.min[1], e.range.min[2]), this.shRange.max.value.set(e.range.max[0], e.range.max[1], e.range.max[2]), this.shRangeSet = !0, this.wrotePreLockNeutralSh)) {
-      const t = this.neutralShWord();
-      for (const i of this.backing.shPacked) i.fill(t);
+  applyShRange(t) {
+    if (!this.shRangeSet && (this.shRange.min.value.set(t.range.min[0], t.range.min[1], t.range.min[2]), this.shRange.max.value.set(t.range.max[0], t.range.max[1], t.range.max[2]), this.shRangeSet = !0, this.wrotePreLockNeutralSh)) {
+      const e = this.neutralShWord();
+      for (const i of this.backing.shPacked) i.fill(e);
       this.markRowsWritten(0, this.poolRows), this.wrotePreLockNeutralSh = !1;
     }
   }
   /** The scene's locked packed-SH range as a plain tuple, or null if unset. */
   currentShRange() {
     if (!this.shRangeSet) return null;
-    const { min: e, max: t } = this.shRange;
+    const { min: t, max: e } = this.shRange;
     return {
-      min: [e.value.x, e.value.y, e.value.z],
-      max: [t.value.x, t.value.y, t.value.z]
+      min: [t.value.x, t.value.y, t.value.z],
+      max: [e.value.x, e.value.y, e.value.z]
     };
   }
   /** The packed word decoding to 0 in every channel under the scene's range. */
   neutralShWord() {
-    const e = this.currentShRange();
-    return e ? Lt(e) : 0;
+    const t = this.currentShRange();
+    return t ? Ft(t) : 0;
   }
   /** Warns once per call site when a source's SH cannot be stored. */
-  warnOnIgnoredSh(e, t) {
-    e.sh && !this.isStatic && O(
-      `SplatMesh.${t}: palette shN data on appended ranges is ignored in dynamic-capacity mode (per-file palettes cannot be merged into a shared pool).`
-    ), e.shPacked && this.packedShBands === 0 && O(
-      `SplatMesh.${t}: per-splat SH was supplied but the pool has none allocated ` + (this.isStatic ? "(the static source had no `shPacked` at construction)." : "(construct the mesh with `shBands` to store it).")
+  warnOnIgnoredSh(t, e) {
+    t.sh && !this.isStatic && O(
+      `SplatMesh.${e}: palette shN data on appended ranges is ignored in dynamic-capacity mode (per-file palettes cannot be merged into a shared pool).`
+    ), t.shPacked && this.packedShBands === 0 && O(
+      `SplatMesh.${e}: per-splat SH was supplied but the pool has none allocated ` + (this.isStatic ? "(the static source had no `shPacked` at construction)." : "(construct the mesh with `shBands` to store it).")
     );
   }
   /** Atomically includes or excludes a resident range on the next active-list rebuild. */
-  setRangeActive(e, t) {
-    const i = this.ranges.get(e);
+  setRangeActive(t, e) {
+    const i = this.ranges.get(t);
     if (!i) throw new Error("SplatMesh.setRangeActive: unknown range handle.");
-    i.active !== t && (i.active = t, t ? this.activateRecord(i) : this.deactivateRecord(i), this.contentRevision++);
+    i.active !== e && (i.active = e, e ? this.activateRecord(i) : this.deactivateRecord(i), this.contentRevision++);
   }
   /**
    * Activates only the first `prefix` splats of a range (see
@@ -905,10 +914,10 @@ const Yt = 4, v = class v extends d.Mesh {
    * work to the *drawn* frontier instead of the whole pool-sized slab. Write
    * APIs (`overwriteRangeData` / `degenerateRange`) still address the full range.
    */
-  setRangeActivePrefix(e, t) {
-    const i = this.ranges.get(e);
+  setRangeActivePrefix(t, e) {
+    const i = this.ranges.get(t);
     if (!i) throw new Error("SplatMesh.setRangeActivePrefix: unknown range handle.");
-    const s = Math.max(0, Math.min(i.count, Math.floor(t))), r = i.active ? i.activePrefix ?? i.count : 0;
+    const s = Math.max(0, Math.min(i.count, Math.floor(e))), r = i.active ? i.activePrefix ?? i.count : 0;
     s !== r && (i.active && (this.deactivateRecord(i), i.active = !1), i.activePrefix = s, s > 0 && (i.active = !0, this.activateRecord(i)), this.contentRevision++);
   }
   /**
@@ -918,14 +927,14 @@ const Yt = 4, v = class v extends d.Mesh {
    * an arbitrary hierarchy frontier, but the referenced pool rows must remain
    * resident for the lifetime of the mesh.
    */
-  replaceActiveIndices(e) {
-    const t = this.sourceIndexAttribute.array;
-    if (e.length > t.length)
+  replaceActiveIndices(t) {
+    const e = this.sourceIndexAttribute.array;
+    if (t.length > e.length)
       throw new RangeError("SplatMesh.replaceActiveIndices: frontier exceeds pool capacity.");
     this.activeSlotByPoolIndex.fill(4294967295);
-    for (let s = 0; s < e.length; s++) {
-      const r = e[s];
-      if (r >= t.length)
+    for (let s = 0; s < t.length; s++) {
+      const r = t[s];
+      if (r >= e.length)
         throw new RangeError(
           "SplatMesh.replaceActiveIndices: frontier contains an invalid pool index."
         );
@@ -933,50 +942,50 @@ const Yt = 4, v = class v extends d.Mesh {
         throw new Error(
           "SplatMesh.replaceActiveIndices: frontier contains duplicate pool indices."
         );
-      t[s] = r, this.activeSlotByPoolIndex[r] = s;
+      e[s] = r, this.activeSlotByPoolIndex[r] = s;
     }
     const i = this.activeCount;
-    this.activeCount = e.length, this.commitActiveListMutation(0, Math.max(i, this.activeCount)), this.queryEpoch++, this.contentRevision++;
+    this.activeCount = t.length, this.commitActiveListMutation(0, Math.max(i, this.activeCount)), this.queryEpoch++, this.contentRevision++;
   }
   /** Fast identity-frontier variant that avoids allocating a large index array. */
-  replaceActivePrefix(e) {
-    const t = this.sourceIndexAttribute.array, i = Math.max(0, Math.min(t.length, Math.floor(e)));
+  replaceActivePrefix(t) {
+    const e = this.sourceIndexAttribute.array, i = Math.max(0, Math.min(e.length, Math.floor(t)));
     this.activeSlotByPoolIndex.fill(4294967295);
     for (let r = 0; r < i; r++)
-      t[r] = r, this.activeSlotByPoolIndex[r] = r;
+      e[r] = r, this.activeSlotByPoolIndex[r] = r;
     const s = this.activeCount;
     this.activeCount = i, this.commitActiveListMutation(0, Math.max(s, i)), this.queryEpoch++, this.contentRevision++;
   }
   /** Replaces a static mesh's resident cut without increasing its fixed pool allocation. */
-  replaceStaticData(e) {
+  replaceStaticData(t) {
     if (!this.isStatic || !this.staticRange)
       throw new Error("SplatMesh.replaceStaticData: mesh was not constructed from static data.");
-    if (e.count > this.capacity)
+    if (t.count > this.capacity)
       throw new RangeError("SplatMesh.replaceStaticData: cut exceeds pool capacity.");
-    this.overwriteRangeData(this.staticRange, e, 0), this.setRangeActivePrefix(this.staticRange, e.count), this.invalidateSort();
+    this.overwriteRangeData(this.staticRange, t, 0), this.setRangeActivePrefix(this.staticRange, t.count), this.invalidateSort();
   }
-  appendRangeWithState(e, t) {
-    if (e.count === 0) {
-      const h = Object.freeze({ count: 0 });
-      return this.ranges.set(h, { startRow: 0, rowCount: 0, start: 0, count: 0, active: t }), h;
+  appendRangeWithState(t, e) {
+    if (t.count === 0) {
+      const c = Object.freeze({ count: 0 });
+      return this.ranges.set(c, { startRow: 0, rowCount: 0, start: 0, count: 0, active: e }), c;
     }
-    const i = v.DATA_TEXTURE_WIDTH, s = Math.ceil(e.count / i), r = Q(this.freeRowSpans, s, this.poolRows), n = r * i;
-    this.warnOnIgnoredSh(e, "appendRange"), this.writeSplatRows(n, e);
-    const a = Object.freeze({ count: e.count }), c = { startRow: r, rowCount: s, start: n, count: e.count, active: t };
-    this.ranges.set(a, c), this.markRowsWritten(r, s);
-    for (const h of this.channels.values())
-      h.backing.fill(h.fill, n, n + s * i), h.pendingRows.push({ start: r, count: s });
-    return F.setFromArray(e.positions), this.localBounds.union(F), this.boundsDirty = !0, t && this.activateRecord(c), this.contentRevision++, a;
+    const i = v.DATA_TEXTURE_WIDTH, s = Math.ceil(t.count / i), r = Q(this.freeRowSpans, s, this.poolRows), n = r * i;
+    this.warnOnIgnoredSh(t, "appendRange"), this.writeSplatRows(n, t);
+    const a = Object.freeze({ count: t.count }), h = { startRow: r, rowCount: s, start: n, count: t.count, active: e };
+    this.ranges.set(a, h), this.markRowsWritten(r, s);
+    for (const c of this.channels.values())
+      c.backing.fill(c.fill, n, n + s * i), c.pendingRows.push({ start: r, count: s });
+    return F.setFromArray(t.positions), this.localBounds.union(F), this.boundsDirty = !0, e && this.activateRecord(h), this.contentRevision++, a;
   }
   /**
    * Deactivates a previously appended range and frees its pool rows for
    * reuse. The bounding sphere used for depth quantization stays a
    * conservative superset until new ranges grow it again.
    */
-  removeRange(e) {
-    const t = this.ranges.get(e);
-    if (!t) throw new Error("SplatMesh.removeRange: unknown range handle.");
-    t.active && this.deactivateRecord(t), this.ranges.delete(e), t.rowCount > 0 && (this.freeRowSpans = Mt(this.freeRowSpans, t.startRow, t.rowCount)), this.contentRevision++;
+  removeRange(t) {
+    const e = this.ranges.get(t);
+    if (!e) throw new Error("SplatMesh.removeRange: unknown range handle.");
+    e.active && this.deactivateRecord(e), this.ranges.delete(t), e.rowCount > 0 && (this.freeRowSpans = Mt(this.freeRowSpans, e.startRow, e.rowCount)), this.contentRevision++;
   }
   /** Maximum number of splats the pool can hold (row-aligned internally). */
   get capacity() {
@@ -994,8 +1003,8 @@ const Yt = 4, v = class v extends d.Mesh {
    */
   getUnifiedSourceView() {
     this.updateWorldMatrix(!0, !1), this.refreshSortBounds();
-    const e = this.cachedUnifiedView;
-    return e !== null && e.contentRevision === this.contentRevision && e.graphRevision === this.graphRevision && e.activeCount === this.activeCount && e.sh === this.materialInputs.sh && e.modifiers === this.modifierList && e.hasSourcePlacement === (this.perSourceSort !== null) && e.centersTexture === this.centersTexture && e.colorsTexture === this.materialInputs.textures.colorsTexture && this.cachedUnifiedViewMatrixWorld.equals(this.matrixWorld) && this.cachedUnifiedViewLocalBounds.equals(this.boundingSphereLocal) ? e : (this.cachedUnifiedViewMatrixWorld.copy(this.matrixWorld), this.cachedUnifiedViewLocalBounds.copy(this.boundingSphereLocal), this.cachedUnifiedViewWorldBounds.copy(this.boundingSphereLocal).applyMatrix4(this.matrixWorld), this.cachedUnifiedView = {
+    const t = this.cachedUnifiedView;
+    return t !== null && t.contentRevision === this.contentRevision && t.graphRevision === this.graphRevision && t.activeCount === this.activeCount && t.sh === this.materialInputs.sh && t.modifiers === this.modifierList && t.hasSourcePlacement === (this.perSourceSort !== null) && t.centersTexture === this.centersTexture && t.colorsTexture === this.materialInputs.textures.colorsTexture && this.cachedUnifiedViewMatrixWorld.equals(this.matrixWorld) && this.cachedUnifiedViewLocalBounds.equals(this.boundingSphereLocal) ? t : (this.cachedUnifiedViewMatrixWorld.copy(this.matrixWorld), this.cachedUnifiedViewLocalBounds.copy(this.boundingSphereLocal), this.cachedUnifiedViewWorldBounds.copy(this.boundingSphereLocal).applyMatrix4(this.matrixWorld), this.cachedUnifiedView = {
       capacity: this.capacity,
       sourceIndex: this.sourceIndexAttribute,
       activeCount: this.activeCount,
@@ -1028,8 +1037,8 @@ const Yt = 4, v = class v extends d.Mesh {
    * mirrors this resolved visibility so existing per-source hit testing works.
    * Internal consumers should clear the state with `null` before disposing.
    */
-  setUnifiedPickVisibility(e) {
-    this.unifiedPickVisibility = e;
+  setUnifiedPickVisibility(t) {
+    this.unifiedPickVisibility = t;
   }
   /**
    * The visibility that actually decides whether this mesh's splats reach the
@@ -1051,9 +1060,9 @@ const Yt = 4, v = class v extends d.Mesh {
    * falling back to {@link compact}.
    */
   get freeSplatCapacity() {
-    let e = 0;
-    for (const t of this.freeRowSpans) e += t.count;
-    return e * v.DATA_TEXTURE_WIDTH;
+    let t = 0;
+    for (const e of this.freeRowSpans) t += e.count;
+    return t * v.DATA_TEXTURE_WIDTH;
   }
   /**
    * Declares a named per-splat data channel - one extra value per pool slot,
@@ -1069,19 +1078,19 @@ const Yt = 4, v = class v extends d.Mesh {
    *
    * @throws {Error} if a channel of this name already exists.
    */
-  defineChannel(e, t = {}) {
-    if (this.channels.has(e))
-      throw new Error(`SplatMesh.defineChannel: channel "${e}" already defined.`);
-    const i = t.type ?? "float", s = v.DATA_TEXTURE_WIDTH, r = s * this.poolRows, n = i === "byte" ? new Uint8Array(r) : new Float32Array(r), a = t.fill ?? 0;
+  defineChannel(t, e = {}) {
+    if (this.channels.has(t))
+      throw new Error(`SplatMesh.defineChannel: channel "${t}" already defined.`);
+    const i = e.type ?? "float", s = v.DATA_TEXTURE_WIDTH, r = s * this.poolRows, n = i === "byte" ? new Uint8Array(r) : new Float32Array(r), a = e.fill ?? 0;
     a && n.fill(a);
-    const c = i === "byte" ? d.UnsignedByteType : d.FloatType, h = new d.DataTexture(
+    const h = i === "byte" ? d.UnsignedByteType : d.FloatType, c = new d.DataTexture(
       n,
       s,
       this.poolRows,
       d.RedFormat,
-      c
+      h
     );
-    h.needsUpdate = !0, this.channels.set(e, { type: i, fill: a, backing: n, texture: h, textureType: c, pendingRows: [] });
+    c.needsUpdate = !0, this.channels.set(t, { type: i, fill: a, backing: n, texture: c, textureType: h, pendingRows: [] });
   }
   /**
    * Writes channel values for a resident range, at `[offset, offset + data.length)`
@@ -1091,20 +1100,20 @@ const Yt = 4, v = class v extends d.Mesh {
    *
    * @throws {Error} for an unknown channel or range, or a write past the range.
    */
-  writeChannel(e, t, i, s = 0) {
-    const r = this.channels.get(t);
-    if (!r) throw new Error(`SplatMesh.writeChannel: channel "${t}" is not defined.`);
-    const n = this.ranges.get(e);
+  writeChannel(t, e, i, s = 0) {
+    const r = this.channels.get(e);
+    if (!r) throw new Error(`SplatMesh.writeChannel: channel "${e}" is not defined.`);
+    const n = this.ranges.get(t);
     if (!n) throw new Error("SplatMesh.writeChannel: unknown range handle.");
     if (s < 0 || s + i.length > n.count)
       throw new Error(
         `SplatMesh.writeChannel: write of ${i.length} at offset ${s} exceeds range count ${n.count}.`
       );
     if (i.length === 0) return;
-    const a = v.DATA_TEXTURE_WIDTH, c = n.start + s;
-    r.backing.set(i, c);
-    const h = Math.floor(c / a), l = Math.floor((c + i.length - 1) / a);
-    r.pendingRows.push({ start: h, count: l - h + 1 }), this.contentRevision++;
+    const a = v.DATA_TEXTURE_WIDTH, h = n.start + s;
+    r.backing.set(i, h);
+    const c = Math.floor(h / a), l = Math.floor((h + i.length - 1) / a);
+    r.pendingRows.push({ start: c, count: l - c + 1 }), this.contentRevision++;
   }
   /**
    * Effect hooks, folded into the vertex stage in array order - each
@@ -1117,10 +1126,10 @@ const Yt = 4, v = class v extends d.Mesh {
   get modifiers() {
     return this.modifierList;
   }
-  set modifiers(e) {
-    if (e.length === this.modifierList.length && e.every((s, r) => s === this.modifierList[r])) return;
+  set modifiers(t) {
+    if (t.length === this.modifierList.length && t.every((s, r) => s === this.modifierList[r])) return;
     const i = this.modifierList;
-    this.modifierList = [...e];
+    this.modifierList = [...t];
     try {
       this.rebuildGraph();
     } catch (s) {
@@ -1147,9 +1156,9 @@ const Yt = 4, v = class v extends d.Mesh {
    * after EWA projection (not the stylized M13 scale modifier). Live uniforms
    * - no material rebuild. Pass `aperture: 0` to disable.
    */
-  setDepthOfField(e) {
-    const t = It(e, this.getDepthOfField());
-    this.dofFocusDistance.value = t.focusDistance, this.dofAperture.value = t.aperture;
+  setDepthOfField(t) {
+    const e = It(t, this.getDepthOfField());
+    this.dofFocusDistance.value = e.focusDistance, this.dofAperture.value = e.aperture;
   }
   /**
    * PlayCanvas-style proxy-mesh relighting. Multiplies baked splat color in the
@@ -1160,13 +1169,13 @@ const Yt = 4, v = class v extends d.Mesh {
    * the map texture identity rebuilds the material once. Does not affect the
    * pick pass. Does not invalidate a unified gather cache.
    */
-  setRelighting(e) {
-    if (e === null) {
+  setRelighting(t) {
+    if (t === null) {
       this.relightBlend.value = 0, this.relightMap !== this.relightPlaceholder && (this.relightMap = this.relightPlaceholder, this.rebuildGraph());
       return;
     }
-    const t = kt(e, this.getRelighting());
-    this.relightBlend.value = t.blend, this.relightBrightness.value = t.brightness, this.relightBackground.value = t.background, this.relightSoftness.value = t.softness, e.map !== this.relightMap && (this.relightMap = e.map, this.rebuildGraph());
+    const e = kt(t, this.getRelighting());
+    this.relightBlend.value = e.blend, this.relightBrightness.value = e.brightness, this.relightBackground.value = e.background, this.relightSoftness.value = e.softness, t.map !== this.relightMap && (this.relightMap = t.map, this.rebuildGraph());
   }
   /** Current relight numeric uniforms (`blend === 0` means off). */
   getRelighting() {
@@ -1189,8 +1198,8 @@ const Yt = 4, v = class v extends d.Mesh {
    * selects smaller splats, and a band left where it was would cull precisely
    * the detail that refinement bought.
    */
-  setScreenRadiusBand(e, t) {
-    this.screenBandMin.value = Math.max(0, e), this.screenBandMax.value = Math.max(0, t);
+  setScreenRadiusBand(t, e) {
+    this.screenBandMin.value = Math.max(0, t), this.screenBandMax.value = Math.max(0, e);
   }
   /** Current core DoF uniforms (`aperture === 0` means off). */
   getDepthOfField() {
@@ -1219,13 +1228,13 @@ const Yt = 4, v = class v extends d.Mesh {
    * {@link SplatPoolTenant}: follow one range to its new rows. The pool has
    * already moved the splat data; this moves what the mesh keys by pool row.
    */
-  relocatePoolRange(e, t) {
-    const i = e, s = v.DATA_TEXTURE_WIDTH;
+  relocatePoolRange(t, e) {
+    const i = t, s = v.DATA_TEXTURE_WIDTH;
     for (const r of this.channels.values()) {
-      const n = i.startRow * s, a = t * s, c = i.rowCount * s;
-      r.backing.copyWithin(a, n, n + c), r.pendingRows.push({ start: t, count: i.rowCount });
+      const n = i.startRow * s, a = e * s, h = i.rowCount * s;
+      r.backing.copyWithin(a, n, n + h), r.pendingRows.push({ start: e, count: i.rowCount });
     }
-    i.startRow = t, i.start = t * s, this.markRowsWritten(t, i.rowCount);
+    i.startRow = e, i.start = e * s, this.markRowsWritten(e, i.rowCount);
   }
   /** {@link SplatPoolTenant}: rebuild everything keyed by pool index. */
   onPoolCompacted() {
@@ -1236,16 +1245,16 @@ const Yt = 4, v = class v extends d.Mesh {
    * uniforms and requests a depth re-sort when the camera or the content
    * has changed. Call this every frame, before `renderer.render`.
    */
-  update(e, t, i = {}) {
+  update(t, e, i = {}) {
     if (this.disposed) return;
-    this.lastRenderer = t, this.assertPoolFitsDevice(t), e.updateMatrixWorld(), this.updateWorldMatrix(!0, !1), this.updateTimings.activeListMs = 0, this.updateTimings.uploadMs = 0, this.updateTimings.sortSubmitMs = 0, this.updateTimings.stagingTextureAllocations = 0, this.updateTimings.activeListUpdateRanges = 0;
+    this.lastRenderer = e, this.assertPoolFitsDevice(e), t.updateMatrixWorld(), this.updateWorldMatrix(!0, !1), this.updateTimings.activeListMs = 0, this.updateTimings.uploadMs = 0, this.updateTimings.sortSubmitMs = 0, this.updateTimings.stagingTextureAllocations = 0, this.updateTimings.activeListUpdateRanges = 0;
     const s = performance.now();
-    this.flushPendingUploads(t), this.updateTimings.uploadMs = performance.now() - s;
-    const r = Pt(e, t);
-    let n = e, a = e, c, h;
-    if (r ? (n = r.eye, a = r.head, c = r.width, h = r.height) : (t.getDrawingBufferSize(P), c = P.x, h = P.y), this.adaptFoveationLimit(n, h), this.writeViewUniforms(n, c, h, a), this.updateTimings.activeListUpdateRanges = this.sourceIndexAttribute.updateRanges.length, i.sort !== !1) {
+    this.flushPendingUploads(e), this.updateTimings.uploadMs = performance.now() - s;
+    const r = Pt(t, e);
+    let n = t, a = t, h, c;
+    if (r ? (n = r.eye, a = r.head, h = r.width, c = r.height) : (e.getDrawingBufferSize(P), h = P.x, c = P.y), this.adaptFoveationLimit(n, c), this.writeViewUniforms(n, h, c, a), this.updateTimings.activeListUpdateRanges = this.sourceIndexAttribute.updateRanges.length, i.sort !== !1) {
       const l = performance.now();
-      this.requestSortIfNeeded(a, t), this.updateTimings.sortSubmitMs = performance.now() - l;
+      this.requestSortIfNeeded(a, e), this.updateTimings.sortSubmitMs = performance.now() - l;
     }
   }
   /** Returns the render-preparation CPU timings for the current update. */
@@ -1271,14 +1280,14 @@ const Yt = 4, v = class v extends d.Mesh {
    * 16.7 M splats). If the limit can't be read, the check is skipped rather
    * than risk a false rejection.
    */
-  assertPoolFitsDevice(e) {
+  assertPoolFitsDevice(t) {
     if (this.textureLimitChecked) return;
     this.textureLimitChecked = !0;
-    const t = Ct(e);
-    if (t > 0 && this.poolRows > t) {
+    const e = Ct(t);
+    if (e > 0 && this.poolRows > e) {
       const i = v.DATA_TEXTURE_WIDTH;
       throw new Error(
-        `SplatMesh: this scene needs a ${i}×${this.poolRows} data texture, but this device caps texture dimensions at ${t} (about ${(t * i).toLocaleString("en-US")} splats). Stream it with StreamedSplatMesh, or reduce the splat count.`
+        `SplatMesh: this scene needs a ${i}×${this.poolRows} data texture, but this device caps texture dimensions at ${e} (about ${(e * i).toLocaleString("en-US")} splats). Stream it with StreamedSplatMesh, or reduce the splat count.`
       );
     }
   }
@@ -1298,8 +1307,8 @@ const Yt = 4, v = class v extends d.Mesh {
    * Does not return a persistent splat id - LOD streaming and pool reuse make
    * identity unstable across frames.
    */
-  pick(e, t, i, s) {
-    return this.picker.pick(e, t, i, s);
+  pick(t, e, i, s) {
+    return this.picker.pick(t, e, i, s);
   }
   /**
    * The resident splat center nearest a world point, within `radius` (world
@@ -1320,15 +1329,15 @@ const Yt = 4, v = class v extends d.Mesh {
    * in an ancestor transform is not supported. Splats displaced by GPU
    * modifiers are queried at their undisplaced CPU positions.
    */
-  queryNearest(e, t) {
-    if (this.activeCount === 0 || !(t >= 0)) return null;
-    this.updateWorldMatrix(!0, !1), T.copy(e), this.worldToLocal(T);
-    const i = this.ensureQueryGrid(), s = t / this.queryWorldMinScale(), r = t * t;
+  queryNearest(t, e) {
+    if (this.activeCount === 0 || !(e >= 0)) return null;
+    this.updateWorldMatrix(!0, !1), T.copy(t), this.worldToLocal(T);
+    const i = this.ensureQueryGrid(), s = e / this.queryWorldMinScale(), r = e * e;
     let n = -1, a = 1 / 0;
-    return i.forEachWithin(T.x, T.y, T.z, s, (h) => {
-      this.splatWorldPosition(h, k);
-      const l = k.distanceToSquared(e);
-      l <= r && l < a && (a = l, n = h);
+    return i.forEachWithin(T.x, T.y, T.z, s, (c) => {
+      this.splatWorldPosition(c, k);
+      const l = k.distanceToSquared(t);
+      l <= r && l < a && (a = l, n = c);
     }), n < 0 ? null : { point: this.splatWorldPosition(n, new d.Vector3()), distance: Math.sqrt(a) };
   }
   /**
@@ -1340,19 +1349,19 @@ const Yt = 4, v = class v extends d.Mesh {
    *
    * Like {@link queryNearest}, this searches resident, undisplaced CPU centers.
    */
-  queryRay(e, t = 0.025, i = 0.05) {
-    if (this.activeCount === 0 || !(t >= 0) || !(i >= 0) || e.direction.lengthSq() === 0)
+  queryRay(t, e = 0.025, i = 0.05) {
+    if (this.activeCount === 0 || !(e >= 0) || !(i >= 0) || t.direction.lengthSq() === 0)
       return null;
     this.updateWorldMatrix(!0, !1);
     const s = this.sourceIndexAttribute.array.subarray(0, this.activeCount);
     let r = -1, n = 1 / 0;
     for (const a of s) {
-      this.splatWorldPosition(a, k), T.subVectors(k, e.origin);
-      const c = T.dot(e.direction);
-      if (c < 0 || c >= n) continue;
-      T.addScaledVector(e.direction, -c);
-      const h = Math.max(i, c * t);
-      T.lengthSq() <= h * h && (r = a, n = c);
+      this.splatWorldPosition(a, k), T.subVectors(k, t.origin);
+      const h = T.dot(t.direction);
+      if (h < 0 || h >= n) continue;
+      T.addScaledVector(t.direction, -h);
+      const c = Math.max(i, h * e);
+      T.lengthSq() <= c * c && (r = a, n = h);
     }
     return r < 0 ? null : {
       point: this.splatWorldPosition(r, new d.Vector3()),
@@ -1374,20 +1383,20 @@ const Yt = 4, v = class v extends d.Mesh {
    * every candidate is judged in world space, where the −Y probe direction is
    * defined, so the vertical test never assumes local axis alignment.
    */
-  queryHeight(e, t, i = t / 2) {
-    if (this.activeCount === 0 || !(t >= 0) || !(i >= 0)) return null;
-    this.updateWorldMatrix(!0, !1), T.copy(e), this.worldToLocal(T);
-    const s = this.ensureQueryGrid(), r = (t + i) / this.queryWorldMinScale(), n = i * i;
-    let a = -1 / 0, c = -1;
+  queryHeight(t, e, i = e / 2) {
+    if (this.activeCount === 0 || !(e >= 0) || !(i >= 0)) return null;
+    this.updateWorldMatrix(!0, !1), T.copy(t), this.worldToLocal(T);
+    const s = this.ensureQueryGrid(), r = (e + i) / this.queryWorldMinScale(), n = i * i;
+    let a = -1 / 0, h = -1;
     if (s.forEachWithin(T.x, T.y, T.z, r, (l) => {
       this.splatWorldPosition(l, k);
-      const f = e.y - k.y;
-      if (f < 0 || f > t) return;
-      const x = k.x - e.x, p = k.z - e.z;
-      x * x + p * p > n || k.y > a && (a = k.y, c = l);
-    }), c < 0) return null;
-    const h = this.splatWorldPosition(c, new d.Vector3());
-    return { point: h, drop: e.y - h.y };
+      const f = t.y - k.y;
+      if (f < 0 || f > e) return;
+      const x = k.x - t.x, p = k.z - t.z;
+      x * x + p * p > n || k.y > a && (a = k.y, h = l);
+    }), h < 0) return null;
+    const c = this.splatWorldPosition(h, new d.Vector3());
+    return { point: c, drop: t.y - c.y };
   }
   /**
    * Renders this mesh from a second camera - into `target`, or the canvas when
@@ -1411,39 +1420,39 @@ const Yt = 4, v = class v extends d.Mesh {
    *
    * @param target - Destination render target, or `null`/omitted for the canvas.
    */
-  renderView(e, t, i = null) {
+  renderView(t, e, i = null) {
     if (this.disposed) return;
-    this.lastRenderer = t, e.updateMatrixWorld(), this.updateWorldMatrix(!0, !1), this.flushPendingUploads(t), i ? P.set(i.width, i.height) : t.getDrawingBufferSize(P), this.writeViewUniforms(e, P.x, P.y);
-    const s = this.sortForView(e, t), r = t.getRenderTarget();
+    this.lastRenderer = e, t.updateMatrixWorld(), this.updateWorldMatrix(!0, !1), this.flushPendingUploads(e), i ? P.set(i.width, i.height) : e.getDrawingBufferSize(P), this.writeViewUniforms(t, P.x, P.y);
+    const s = this.sortForView(t, e), r = e.getRenderTarget();
     try {
-      t.setRenderTarget(i), t.render(this, e);
+      e.setRenderTarget(i), e.render(this, t);
     } finally {
-      t.setRenderTarget(r), s && (this.orderIsForeign = !0);
+      e.setRenderTarget(r), s && (this.orderIsForeign = !0);
     }
   }
   /**
    * Sorts the shared order buffer for a secondary view's camera, bypassing the
-   * primary view's sort scheduler and its `lastSortedModelView` record (that
+   * primary view's sort scheduler and its last-sorted pose record (that
    * state belongs to `update()`'s camera). WebGPU dispatches synchronously into
    * the render queue, so the following draw reads this order.
    */
-  sortForView(e, t) {
-    return this.activeCount === 0 || !(t.backend.isWebGPUBackend === !0) || (this.currentModelView.multiplyMatrices(e.matrixWorldInverse, this.matrixWorld), this.refreshSortBounds(), this.sorter ?? (this.sorter = this.createSorter(t)), !this.sorter) ? !1 : (this.sorter.sort(this.currentModelView, this.activeCount, this.boundingSphereLocal), !0);
+  sortForView(t, e) {
+    return this.activeCount === 0 || !(e.backend.isWebGPUBackend === !0) || (this.currentModelView.multiplyMatrices(t.matrixWorldInverse, this.matrixWorld), this.refreshSortBounds(), this.sorter ?? (this.sorter = this.createSorter(e)), !this.sorter) ? !1 : (this.sorter.sort(this.currentModelView, this.activeCount, this.boundingSphereLocal), !0);
   }
   /** Rebuilds the query grid if the resident set changed since it was built. */
   ensureQueryGrid() {
     if (this.queryGrid && this.queryGridEpoch === this.queryEpoch) return this.queryGrid;
-    const e = this.sourceIndexAttribute.array.subarray(0, this.activeCount);
-    return this.queryGrid = new $t(this.backing.centers, e, this.activeCount), this.queryGridEpoch = this.queryEpoch, this.queryGrid;
+    const t = this.sourceIndexAttribute.array.subarray(0, this.activeCount);
+    return this.queryGrid = new Yt(this.backing.centers, t, this.activeCount), this.queryGridEpoch = this.queryEpoch, this.queryGrid;
   }
   /** World-space position of pool splat `poolIndex`, written into `out`. */
-  splatWorldPosition(e, t) {
-    const i = e * 4;
-    return t.set(
+  splatWorldPosition(t, e) {
+    const i = t * 4;
+    return e.set(
       this.backing.centers[i],
       this.backing.centers[i + 1],
       this.backing.centers[i + 2]
-    ), t.applyMatrix4(this.matrixWorld);
+    ), e.applyMatrix4(this.matrixWorld);
   }
   /**
    * The smallest world axis scale, for conservatively mapping a world radius
@@ -1451,7 +1460,7 @@ const Yt = 4, v = class v extends d.Mesh {
    * of `r / minAxisScale`, for any per-axis (non-uniform) scale.
    */
   queryWorldMinScale() {
-    return this.getWorldScale(q), Math.min(Math.abs(q.x), Math.abs(q.y), Math.abs(q.z)) || 1;
+    return this.getWorldScale(z), Math.min(Math.abs(z.x), Math.abs(z.y), Math.abs(z.z)) || 1;
   }
   /**
    * Releases every GPU resource and worker this mesh owns. Idempotent: a
@@ -1460,24 +1469,24 @@ const Yt = 4, v = class v extends d.Mesh {
    * become no-ops after dispose.
    */
   dispose() {
-    var e;
+    var t;
     if (!this.disposed) {
-      this.disposed = !0, (e = this.sorter) == null || e.dispose(), this.sorter = null, this.geometry.dispose(), this.material.dispose(), this.picker.dispose(), this.relightPlaceholder.dispose();
-      for (const t of this.ranges.values())
-        this.pool.releaseRows(t.startRow, t.rowCount);
+      this.disposed = !0, (t = this.sorter) == null || t.dispose(), this.sorter = null, this.geometry.dispose(), this.material.dispose(), this.picker.dispose(), this.relightPlaceholder.dispose();
+      for (const e of this.ranges.values())
+        this.pool.releaseRows(e.startRow, e.rowCount);
       this.pool.unregister(this), this.ownsPool && this.pool.dispose();
-      for (const t of this.dataTextures)
-        !this.ownsPool && this.pool.isPoolTexture(t) || t.dispose();
-      for (const t of this.channels.values()) t.texture.dispose();
+      for (const e of this.dataTextures)
+        !this.ownsPool && this.pool.isPoolTexture(e) || e.dispose();
+      for (const e of this.channels.values()) e.texture.dispose();
       this.channels.clear();
-      for (const t of this.uploadStaging.values())
-        for (const i of t.values()) i.dispose();
+      for (const e of this.uploadStaging.values())
+        for (const i of e.values()) i.dispose();
       this.uploadStaging.clear(), this.halfEncodeBuffers.clear(), this.lastRenderer && (Ut(this.lastRenderer, [this.sourceIndexAttribute]), this.lastRenderer = null), this.pendingUploadRows = [], this.workerDirtyRows = [], this.queryGrid = null, this.ranges.clear();
     }
   }
   /** Matches the viewport / focal / local-camera uniforms written by {@link update}. */
-  refreshProjectionUniforms(e, t) {
-    t.getDrawingBufferSize(P), this.writeViewUniforms(e, P.x, P.y);
+  refreshProjectionUniforms(t, e) {
+    e.getDrawingBufferSize(P), this.writeViewUniforms(t, P.x, P.y);
   }
   /**
    * Writes the three view-dependent uniforms - viewport, focal (splat screen
@@ -1492,10 +1501,10 @@ const Yt = 4, v = class v extends d.Mesh {
    * head, so both eyes shade from one cyclopean point while each still
    * projects through its own eye.
    */
-  writeViewUniforms(e, t, i, s = e) {
-    this.viewport.value.set(t, i);
-    const r = e.projectionMatrix.elements, n = r[5] * i / 2;
-    this.focal.value.set(r[0] * t / 2, n), s.getWorldPosition(this.localCameraPosition.value), this.worldToLocal(this.localCameraPosition.value), this.foveationMode === "frontier" && n > 0 && (this.pixelScaleLimit.value = this.foveationLimitPx / n);
+  writeViewUniforms(t, e, i, s = t) {
+    this.viewport.value.set(e, i);
+    const r = t.projectionMatrix.elements, n = r[5] * i / 2;
+    this.focal.value.set(r[0] * e / 2, n), s.getWorldPosition(this.localCameraPosition.value), this.worldToLocal(this.localCameraPosition.value), this.foveationMode === "frontier" && n > 0 && (this.pixelScaleLimit.value = this.foveationLimitPx / n);
   }
   /**
    * Self-adjusts {@link foveationLimitPx} so the frontier cut's drawn-splat count
@@ -1511,84 +1520,84 @@ const Yt = 4, v = class v extends d.Mesh {
    * here against a per-eye viewport there) makes the estimator judge a cut the
    * shader is not applying, and the ratchet runs away toward the maximum.
    */
-  adaptFoveationLimit(e, t) {
+  adaptFoveationLimit(t, e) {
     if (this.foveationMode !== "frontier") return;
     const i = performance.now();
-    if (i - this.lastFoveationAdaptAt < Kt) return;
+    if (i - this.lastFoveationAdaptAt < Qt) return;
     this.lastFoveationAdaptAt = i;
-    const s = e.projectionMatrix.elements[5] * t / 2;
+    const s = t.projectionMatrix.elements[5] * e / 2;
     if (!(s > 0)) return;
     const r = this.foveationLimitPx / s;
-    e.getWorldPosition(_), this.worldToLocal(_), ot.copy(e.matrixWorld).invert(), at.multiplyMatrices(ot, this.matrixWorld).premultiply(e.projectionMatrix);
-    const n = at.elements, { covarianceA: a, covarianceB: c, centers: h } = this.backing, l = c.length / 4;
+    t.getWorldPosition(_), this.worldToLocal(_), ot.copy(t.matrixWorld).invert(), at.multiplyMatrices(ot, this.matrixWorld).premultiply(t.projectionMatrix);
+    const n = at.elements, { covarianceA: a, covarianceB: h, centers: c } = this.backing, l = h.length / 4;
     let f = 0, x = 0;
-    for (let m = 0; m < l; m += ht) {
-      const S = m * 4, A = c[S + 3];
+    for (let m = 0; m < l; m += ct) {
+      const S = m * 4, A = h[S + 3];
       if (A === 0) continue;
       f++;
-      const R = h[S], y = h[S + 1], M = h[S + 2], I = (n[3] * R + n[7] * y + n[11] * M + n[15]) * 1.2;
+      const R = c[S], y = c[S + 1], M = c[S + 2], I = (n[3] * R + n[7] * y + n[11] * M + n[15]) * 1.2;
       if (n[2] * R + n[6] * y + n[10] * M + n[14] <= -I) continue;
       const B = n[0] * R + n[4] * y + n[8] * M + n[12];
       if (B > I || B < -I) continue;
       const E = n[1] * R + n[5] * y + n[9] * M + n[13];
       if (E > I || E < -I) continue;
-      const W = a[S] + a[S + 3] + c[S + 1], L = 2 * Math.sqrt(Math.max(W, 0) / 3), C = A < 0, ut = Math.abs(A), N = R - _.x, X = y - _.y, j = M - _.z, $ = r * Math.sqrt(N * N + X * X + j * j), dt = C ? 0 : L;
+      const W = a[S] + a[S + 3] + h[S + 1], L = 2 * Math.sqrt(Math.max(W, 0) / 3), C = A < 0, ut = Math.abs(A), N = R - _.x, X = y - _.y, j = M - _.z, $ = r * Math.sqrt(N * N + X * X + j * j), dt = C ? 0 : L;
       ut > $ && dt <= $ && x++;
     }
     if (f === 0) return;
-    const p = x * ht, w = this.foveationDrawBudget;
-    p > w * 1.1 ? this.foveationLimitPx = Math.min(this.foveationLimitPx * 1.15, Qt) : p < w * 0.7 && (this.foveationLimitPx = Math.max(this.foveationLimitPx / 1.12, this.foveationTargetPx));
+    const p = x * ct, w = this.foveationDrawBudget;
+    p > w * 1.1 ? this.foveationLimitPx = Math.min(this.foveationLimitPx * 1.15, Jt) : p < w * 0.7 && (this.foveationLimitPx = Math.max(this.foveationLimitPx / 1.12, this.foveationTargetPx));
   }
   /** Records a written row span for GPU upload and the sort-worker mirror. */
-  markRowsWritten(e, t) {
+  markRowsWritten(t, e) {
     var i;
-    this.pendingUploadRows.push({ start: e, count: t }), ((i = this.sorter) == null ? void 0 : i.kind) === "worker" && this.workerDirtyRows.push({ start: e, count: t });
+    this.pendingUploadRows.push({ start: t, count: e }), ((i = this.sorter) == null ? void 0 : i.kind) === "worker" && this.workerDirtyRows.push({ start: t, count: e });
   }
   /** Appends one newly active pool range to the packed source-index list. */
-  activateRecord(e) {
-    const t = e.activePrefix ?? e.count;
-    if (t === 0) return;
+  activateRecord(t) {
+    const e = t.activePrefix ?? t.count;
+    if (e === 0) return;
     this.queryEpoch++;
     const i = this.sourceIndexAttribute.array, s = this.getPoolIndexTemplate(), r = this.activeCount;
-    i.set(s.subarray(e.start, e.start + t), r), this.activeSlotByPoolIndex.set(
-      s.subarray(r, r + t),
-      e.start
-    ), this.activeCount += t, this.commitActiveListMutation(r, t);
+    i.set(s.subarray(t.start, t.start + e), r), this.activeSlotByPoolIndex.set(
+      s.subarray(r, r + e),
+      t.start
+    ), this.activeCount += e, this.commitActiveListMutation(r, e);
   }
   /**
    * Removes one active range and backfills its holes from the packed tail.
    * The common contiguous case uses one native block copy; the fallback
    * handles a range split by earlier tail backfills in O(record.count).
    */
-  deactivateRecord(e) {
-    const t = e.activePrefix ?? e.count;
-    if (t === 0) return;
+  deactivateRecord(t) {
+    const e = t.activePrefix ?? t.count;
+    if (e === 0) return;
     this.queryEpoch++;
-    const i = this.sourceIndexAttribute.array, s = this.activeSlotByPoolIndex[e.start];
+    const i = this.sourceIndexAttribute.array, s = this.activeSlotByPoolIndex[t.start];
     let r = !0;
-    for (let c = 1; c < t; c++)
-      if (this.activeSlotByPoolIndex[e.start + c] !== s + c) {
+    for (let h = 1; h < e; h++)
+      if (this.activeSlotByPoolIndex[t.start + h] !== s + h) {
         r = !1;
         break;
       }
     let n = this.activeCount, a = 0;
     if (r) {
-      const c = this.activeCount - t, h = Math.min(t, Math.max(0, c - s));
-      if (h > 0) {
-        i.copyWithin(s, this.activeCount - h, this.activeCount);
-        for (let l = 0; l < h; l++) {
+      const h = this.activeCount - e, c = Math.min(e, Math.max(0, h - s));
+      if (c > 0) {
+        i.copyWithin(s, this.activeCount - c, this.activeCount);
+        for (let l = 0; l < c; l++) {
           const f = i[s + l];
           this.activeSlotByPoolIndex[f] = s + l;
         }
-        n = s, a = s + h;
+        n = s, a = s + c;
       }
-      this.activeCount = c;
+      this.activeCount = h;
     } else {
-      for (let c = e.start; c < e.start + t; c++) {
-        const h = this.activeSlotByPoolIndex[c], l = this.activeCount - 1;
-        if (h !== l) {
+      for (let h = t.start; h < t.start + e; h++) {
+        const c = this.activeSlotByPoolIndex[h], l = this.activeCount - 1;
+        if (c !== l) {
           const f = i[l];
-          i[h] = f, this.activeSlotByPoolIndex[f] = h, n = Math.min(n, h), a = Math.max(a, h + 1);
+          i[c] = f, this.activeSlotByPoolIndex[f] = c, n = Math.min(n, c), a = Math.max(a, c + 1);
         }
         this.activeCount--;
       }
@@ -1597,25 +1606,25 @@ const Yt = 4, v = class v extends d.Mesh {
     this.commitActiveListMutation(n, Math.max(0, a - n));
   }
   /** Uploads only the changed packed slots and invalidates the current depth order. */
-  commitActiveListMutation(e, t) {
+  commitActiveListMutation(t, e) {
     var i;
-    if (t > 0 && (z(this.sourceIndexAttribute, e, t), this.sourceIndexAttribute.needsUpdate = !0), ((i = this.sorter) == null ? void 0 : i.kind) === "worker" || this.sorter === null) {
+    if (e > 0 && (q(this.sourceIndexAttribute, t, e), this.sourceIndexAttribute.needsUpdate = !0), ((i = this.sorter) == null ? void 0 : i.kind) === "worker" || this.sorter === null) {
       const s = this.sourceIndexAttribute.array, r = this.splatIndexAttribute.array;
-      this.drawListSorted ? (r.set(s.subarray(0, this.activeCount)), this.activeCount > 0 && z(this.splatIndexAttribute, 0, this.activeCount), this.splatIndexAttribute.needsUpdate = !0, this.drawListSorted = !1) : t > 0 && (r.set(s.subarray(e, e + t), e), z(this.splatIndexAttribute, e, t), this.splatIndexAttribute.needsUpdate = !0);
+      this.drawListSorted ? (r.set(s.subarray(0, this.activeCount)), this.activeCount > 0 && q(this.splatIndexAttribute, 0, this.activeCount), this.splatIndexAttribute.needsUpdate = !0, this.drawListSorted = !1) : e > 0 && (r.set(s.subarray(t, t + e), t), q(this.splatIndexAttribute, t, e), this.splatIndexAttribute.needsUpdate = !0);
     }
     this.geometry.instanceCount = this.activeCount, this.activeListVersion++, this.sortScheduler.invalidateContent();
   }
   /** Rewrites the active-splat list (pool indices, range by range). */
   rebuildActiveList() {
     var s;
-    const e = this.sourceIndexAttribute.array, t = this.getPoolIndexTemplate();
+    const t = this.sourceIndexAttribute.array, e = this.getPoolIndexTemplate();
     let i = 0;
     for (const r of this.ranges.values()) {
       if (!r.active) continue;
       const n = r.activePrefix ?? r.count;
-      e.set(t.subarray(r.start, r.start + n), i), this.activeSlotByPoolIndex.set(t.subarray(i, i + n), r.start), i += n;
+      t.set(e.subarray(r.start, r.start + n), i), this.activeSlotByPoolIndex.set(e.subarray(i, i + n), r.start), i += n;
     }
-    this.activeCount = i, this.sourceIndexAttribute.clearUpdateRanges(), i > 0 && this.sourceIndexAttribute.addUpdateRange(0, i), this.sourceIndexAttribute.needsUpdate = !0, (((s = this.sorter) == null ? void 0 : s.kind) === "worker" || this.sorter === null) && (this.splatIndexAttribute.array.set(e.subarray(0, i)), this.splatIndexAttribute.clearUpdateRanges(), i > 0 && this.splatIndexAttribute.addUpdateRange(0, i), this.splatIndexAttribute.needsUpdate = !0, this.drawListSorted = !1), this.geometry.instanceCount = i, this.activeListVersion++, this.sortScheduler.invalidateContent();
+    this.activeCount = i, this.sourceIndexAttribute.clearUpdateRanges(), i > 0 && this.sourceIndexAttribute.addUpdateRange(0, i), this.sourceIndexAttribute.needsUpdate = !0, (((s = this.sorter) == null ? void 0 : s.kind) === "worker" || this.sorter === null) && (this.splatIndexAttribute.array.set(t.subarray(0, i)), this.splatIndexAttribute.clearUpdateRanges(), i > 0 && this.splatIndexAttribute.addUpdateRange(0, i), this.splatIndexAttribute.needsUpdate = !0, this.drawListSorted = !1), this.geometry.instanceCount = i, this.activeListVersion++, this.sortScheduler.invalidateContent();
   }
   /** The pool's reusable index ramp; shared by every mesh drawing from it. */
   getPoolIndexTemplate() {
@@ -1626,15 +1635,15 @@ const Yt = 4, v = class v extends d.Mesh {
    * through a staging texture. (Constructor-time writes never appear here;
    * they ride the textures' initial full upload instead.)
    */
-  flushPendingUploads(e) {
+  flushPendingUploads(t) {
     if (this.pendingUploadRows.length > 0) {
-      const t = this.poolFloatTextures === "float16" ? d.HalfFloatType : d.FloatType;
-      this.uploadRows(e, this.pendingUploadRows, d.RGBAFormat, 4, [
+      const e = this.poolFloatTextures === "float16" ? d.HalfFloatType : d.FloatType;
+      this.uploadRows(t, this.pendingUploadRows, d.RGBAFormat, 4, [
         {
           key: "centers",
           texture: this.dataTextures[0],
           data: this.backing.centers,
-          type: t,
+          type: e,
           encodeHalf: this.poolFloatTextures === "float16"
         },
         {
@@ -1647,7 +1656,7 @@ const Yt = 4, v = class v extends d.Mesh {
           key: "covarianceA",
           texture: this.dataTextures[2],
           data: this.backing.covarianceA,
-          type: t,
+          type: e,
           encodeHalf: this.poolFloatTextures === "float16"
         },
         {
@@ -1657,7 +1666,7 @@ const Yt = 4, v = class v extends d.Mesh {
           type: d.FloatType
         }
       ]), this.shPackedTextures.length > 0 && this.uploadRows(
-        e,
+        t,
         this.pendingUploadRows,
         d.RGBAIntegerFormat,
         4,
@@ -1669,10 +1678,10 @@ const Yt = 4, v = class v extends d.Mesh {
         }))
       ), this.pendingUploadRows = [];
     }
-    for (const [t, i] of this.channels.entries())
-      i.pendingRows.length !== 0 && (this.uploadRows(e, i.pendingRows, d.RedFormat, 1, [
+    for (const [e, i] of this.channels.entries())
+      i.pendingRows.length !== 0 && (this.uploadRows(t, i.pendingRows, d.RedFormat, 1, [
         {
-          key: `channel:${t}`,
+          key: `channel:${e}`,
           texture: i.texture,
           data: i.backing,
           type: i.textureType
@@ -1685,8 +1694,8 @@ const Yt = 4, v = class v extends d.Mesh {
    * upload carries half bits (staging is skipped for that path).
    */
   syncHalfFloatPoolImages() {
-    const e = this.dataTextures[0], t = this.dataTextures[2], i = e.image.data, s = t.image.data;
-    G(this.backing.centers, i), G(this.backing.covarianceA, s), e.needsUpdate = !0, t.needsUpdate = !0;
+    const t = this.dataTextures[0], e = this.dataTextures[2], i = t.image.data, s = e.image.data;
+    G(this.backing.centers, i), G(this.backing.covarianceA, s), t.needsUpdate = !0, e.needsUpdate = !0;
   }
   /**
    * Uploads the given row spans of one or more same-layout pool textures via
@@ -1694,17 +1703,17 @@ const Yt = 4, v = class v extends d.Mesh {
    * upload as one rectangle each - the copyTextureToTexture call count, not
    * the pixel volume, dominates.
    */
-  uploadRows(e, t, i, s, r) {
-    const n = v.DATA_TEXTURE_WIDTH, a = t.sort((h, l) => h.start - l.start), c = [];
-    for (const h of a) {
-      const l = c[c.length - 1];
-      l && h.start <= l.start + l.count ? l.count = Math.max(l.count, h.start + h.count - l.start) : c.push({ start: h.start, count: h.count });
+  uploadRows(t, e, i, s, r) {
+    const n = v.DATA_TEXTURE_WIDTH, a = e.sort((c, l) => c.start - l.start), h = [];
+    for (const c of a) {
+      const l = h[h.length - 1];
+      l && c.start <= l.start + l.count ? l.count = Math.max(l.count, c.start + c.count - l.start) : h.push({ start: c.start, count: c.count });
     }
-    for (const h of c)
+    for (const c of h)
       for (const { key: l, texture: f, data: x, type: p, encodeHalf: w } of r) {
         const m = x.subarray(
-          h.start * n * s,
-          (h.start + h.count) * n * s
+          c.start * n * s,
+          (c.start + c.count) * n * s
         );
         let S = m;
         if (w) {
@@ -1715,19 +1724,19 @@ const Yt = 4, v = class v extends d.Mesh {
           l,
           S,
           n,
-          h.count,
+          c.count,
           i,
           p
         );
-        e.copyTextureToTexture(A, f, null, Zt.set(0, h.start));
+        t.copyTextureToTexture(A, f, null, Kt.set(0, c.start));
       }
   }
   /** Reuses a same-length half encode buffer for one staging key. */
-  acquireHalfEncodeBuffer(e, t) {
-    const i = this.halfEncodeBuffers.get(e);
-    if (i && i.length === t) return i;
-    const s = new Uint16Array(t);
-    return this.halfEncodeBuffers.set(e, s), s;
+  acquireHalfEncodeBuffer(t, e) {
+    const i = this.halfEncodeBuffers.get(t);
+    if (i && i.length === e) return i;
+    const s = new Uint16Array(e);
+    return this.halfEncodeBuffers.set(t, s), s;
   }
   /**
    * Reuses one of the recent same-sized staging textures for this upload. WebGPU
@@ -1735,25 +1744,25 @@ const Yt = 4, v = class v extends d.Mesh {
    * a small LRU per channel avoids recreating all core/SH staging resources when
    * a stream alternates among a few chunk heights, while bounding GPU memory.
    */
-  acquireUploadStaging(e, t, i, s, r, n) {
+  acquireUploadStaging(t, e, i, s, r, n) {
     var l;
-    let a = this.uploadStaging.get(e);
-    a || (a = /* @__PURE__ */ new Map(), this.uploadStaging.set(e, a));
-    const c = a.get(s);
-    if (c)
-      return c.image = { data: t, width: i, height: s }, c.needsUpdate = !0, a.delete(s), a.set(s, c), c;
-    const h = new d.DataTexture(t, i, s, r, n);
-    if (r === d.RGBAIntegerFormat && (h.magFilter = d.NearestFilter, h.minFilter = d.NearestFilter), h.needsUpdate = !0, a.set(s, h), a.size > Yt) {
+    let a = this.uploadStaging.get(t);
+    a || (a = /* @__PURE__ */ new Map(), this.uploadStaging.set(t, a));
+    const h = a.get(s);
+    if (h)
+      return h.image = { data: e, width: i, height: s }, h.needsUpdate = !0, a.delete(s), a.set(s, h), h;
+    const c = new d.DataTexture(e, i, s, r, n);
+    if (r === d.RGBAIntegerFormat && (c.magFilter = d.NearestFilter, c.minFilter = d.NearestFilter), c.needsUpdate = !0, a.set(s, c), a.size > Zt) {
       const f = a.keys().next().value;
       (l = a.get(f)) == null || l.dispose(), a.delete(f);
     }
-    return this.updateTimings.stagingTextureAllocations++, h;
+    return this.updateTimings.stagingTextureAllocations++, c;
   }
   /** Gathers everything the material graph reads. See `splat-mesh-material.ts`. */
-  graphInputs(e, t) {
+  graphInputs(t, e) {
     return {
-      textures: e,
-      sh: t,
+      textures: t,
+      sh: e,
       sourcePlacement: this.perSourceSort,
       // The uniform node instances, shared with the pick graph on purpose: one
       // per-frame write then reaches both.
@@ -1791,22 +1800,22 @@ const Yt = 4, v = class v extends d.Mesh {
       modifiers: this.modifierList
     };
   }
-  buildMaterial(e, t) {
+  buildMaterial(t, e) {
     Z(
       this.material,
       "display",
-      this.graphInputs(e, t)
+      this.graphInputs(t, e)
     ), this.picker.rebuildMaterial();
   }
-  requestSortIfNeeded(e, t) {
+  requestSortIfNeeded(t, e) {
     if (this.deferSortRequestOnce && (this.deferSortRequestOnce = !1, this.activeListVersion === this.sortedActiveListVersion && !this.orderIsForeign) || this.activeCount === 0) return;
-    this.currentModelView.multiplyMatrices(e.matrixWorldInverse, this.matrixWorld);
-    const i = t.backend.isWebGPUBackend === !0, s = i ? performance.now() : 0;
+    this.currentModelView.multiplyMatrices(t.matrixWorldInverse, this.matrixWorld), this.writeSortState(t);
+    const i = e.backend.isWebGPUBackend === !0, s = i ? performance.now() : 0;
     if (!this.orderIsForeign) {
       if (i) {
         if (!this.sortScheduler.shouldSubmit(
-          this.currentModelView,
-          this.lastSortedModelView,
+          this.currentSortState,
+          this.lastSortedState,
           this.activeCount,
           s
         ))
@@ -1816,11 +1825,11 @@ const Yt = 4, v = class v extends d.Mesh {
         // still invalidated the draw order (the swap reset it to unsorted
         // active order) - skipping here would leave the scene blend-order
         // broken until the camera next moved.
-        !this.sortScheduler.hasPendingForce() && this.currentModelView.equals(this.lastSortedModelView)
+        !this.sortScheduler.hasPendingForce() && this.currentSortState.equals(this.lastSortedState)
       )
         return;
     }
-    this.refreshSortBounds(), this.sorter ?? (this.sorter = this.createSorter(t)), this.sorter && this.sorter.sort(this.currentModelView, this.activeCount, this.boundingSphereLocal) && (this.lastSortedModelView.copy(this.currentModelView), this.sortedActiveListVersion = this.activeListVersion, this.orderIsForeign = !1, this.sortScheduler.markAccepted(s));
+    this.refreshSortBounds(), this.sorter ?? (this.sorter = this.createSorter(e)), this.sorter && this.sorter.sort(this.currentModelView, this.activeCount, this.boundingSphereLocal) && (this.lastSortedState.copy(this.currentSortState), this.sortedActiveListVersion = this.activeListVersion, this.orderIsForeign = !1, this.sortScheduler.markAccepted(s));
   }
   /**
    * Refreshes {@link boundingSphereLocal} - the sphere the sorter quantizes
@@ -1832,16 +1841,16 @@ const Yt = 4, v = class v extends d.Mesh {
     this.boundsDirty && (this.localBounds.getBoundingSphere(this.boundingSphereLocal), this.boundsDirty = !1);
   }
   /** The data texture backing a channel defined with {@link defineChannel}. */
-  channelTexture(e) {
-    var t;
-    return (t = this.channels.get(e)) == null ? void 0 : t.texture;
+  channelTexture(t) {
+    var e;
+    return (e = this.channels.get(t)) == null ? void 0 : e.texture;
   }
   /** CPU backing storage of a float channel, for internal CPU-side consumers. */
-  channelBacking(e) {
-    const t = this.channels.get(e);
-    if (!t || !(t.backing instanceof Float32Array))
-      throw new Error(`SplatMesh: float channel "${e}" is missing.`);
-    return t.backing;
+  channelBacking(t) {
+    const e = this.channels.get(t);
+    if (!e || !(e.backing instanceof Float32Array))
+      throw new Error(`SplatMesh: float channel "${t}" is missing.`);
+    return e.backing;
   }
   /**
    * Forces the next {@link update} to re-sort even if the camera has not moved
@@ -1851,49 +1860,72 @@ const Yt = 4, v = class v extends d.Mesh {
   invalidateSort() {
     this.sortScheduler.invalidate(), this.boundsDirty = !0;
   }
-  createSorter(e) {
-    if (!(e.backend.isWebGPUBackend === !0))
-      return new qt({
-        capacity: this.capacity,
-        rowWidth: v.DATA_TEXTURE_WIDTH,
-        centers: this.backing.centers,
-        perSource: this.perSourceSort ? {
-          sourceIds: this.perSourceSort.sourceIds,
-          matrices: this.perSourceSort.matrices
-        } : void 0,
-        splatIndexAttribute: this.splatIndexAttribute,
-        takeDirtyRows: () => {
-          const s = this.workerDirtyRows;
-          return this.workerDirtyRows = [], s;
-        },
-        getActiveSpans: () => {
-          const s = new Uint32Array(this.ranges.size * 2);
-          let r = 0;
-          for (const n of this.ranges.values()) {
-            if (!n.active) continue;
-            const a = n.activePrefix ?? n.count;
-            a !== 0 && (s[r++] = n.start, s[r++] = a);
+  /**
+   * Writes the camera/mesh state that can change the selected ordering key.
+   * Radial distance is invariant under camera rotation, so its state contains
+   * the mesh's world linear transform and camera-relative translation only.
+   */
+  writeSortState(t) {
+    if (this.sortMetric === "depth") {
+      this.currentSortState.copy(this.currentModelView);
+      return;
+    }
+    Dt(this.matrixWorld, t.matrixWorld, this.currentSortState);
+  }
+  createSorter(t) {
+    if (!(t.backend.isWebGPUBackend === !0) || this.sortStrategy === "worker")
+      return new qt(
+        {
+          capacity: this.capacity,
+          rowWidth: v.DATA_TEXTURE_WIDTH,
+          centers: this.backing.centers,
+          perSource: this.perSourceSort ? {
+            sourceIds: this.perSourceSort.sourceIds,
+            matrices: this.perSourceSort.matrices
+          } : void 0,
+          splatIndexAttribute: this.splatIndexAttribute,
+          takeDirtyRows: () => {
+            const s = this.workerDirtyRows;
+            return this.workerDirtyRows = [], s;
+          },
+          getActiveSpans: () => {
+            const s = new Uint32Array(this.ranges.size * 2);
+            let r = 0;
+            for (const n of this.ranges.values()) {
+              if (!n.active) continue;
+              const a = n.activePrefix ?? n.count;
+              a !== 0 && (s[r++] = n.start, s[r++] = a);
+            }
+            return s.subarray(0, r);
+          },
+          onOrderApplied: () => {
+            this.drawListSorted = !0;
           }
-          return s.subarray(0, r);
         },
-        onOrderApplied: () => {
-          this.drawListSorted = !0;
-        }
-      });
+        this.sortMetric
+      );
     const i = {
-      renderer: e,
+      renderer: t,
       capacity: this.poolRows * v.DATA_TEXTURE_WIDTH,
       centersTexture: this.centersTexture,
       dataTextureWidth: v.DATA_TEXTURE_WIDTH,
       splatIndexAttribute: this.splatIndexAttribute,
       sourceIndexAttribute: this.sourceIndexAttribute
     };
-    return this.perSourceSort ? new tt({ ...i, perSource: this.perSourceSort }) : this.sortStrategy === "radix" || this.sortStrategy === "exact" ? (this.ensureRadixSorter(), this.RadixSorterCtor ? new this.RadixSorterCtor({ ...i, exactDepth: this.sortStrategy === "exact" }) : null) : new tt(i);
+    return this.perSourceSort ? new tt({
+      ...i,
+      perSource: this.perSourceSort,
+      sortMetric: this.sortMetric
+    }) : this.sortStrategy === "radix" || this.sortStrategy === "exact" ? (this.ensureRadixSorter(), this.RadixSorterCtor ? new this.RadixSorterCtor({
+      ...i,
+      exactDepth: this.sortStrategy === "exact",
+      sortMetric: this.sortMetric
+    }) : null) : new tt({ ...i, sortMetric: this.sortMetric });
   }
   /** Prefetches the experimental radix sorter; safe to call repeatedly. */
   ensureRadixSorter() {
-    this.RadixSorterCtor || this.radixSorterLoad || (this.radixSorterLoad = import("./radix-sorter-BrbUg_CV.js").then((e) => {
-      this.RadixSorterCtor = e.RadixSorter;
+    this.RadixSorterCtor || this.radixSorterLoad || (this.radixSorterLoad = import("./radix-sorter-tSffmerk.js").then((t) => {
+      this.RadixSorterCtor = t.RadixSorter;
     }).finally(() => {
       this.radixSorterLoad = null;
     }));
@@ -1901,13 +1933,13 @@ const Yt = 4, v = class v extends d.Mesh {
 };
 o(v, "DATA_TEXTURE_WIDTH", xt);
 let nt = v;
-const F = new d.Box3(), Zt = new d.Vector2(), T = new d.Vector3(), k = new d.Vector3(), q = new d.Vector3(), P = new d.Vector2(), _ = new d.Vector3(), ot = new d.Matrix4(), at = new d.Matrix4(), Kt = 180, ht = 31, Qt = 64;
-function ct(g) {
+const F = new d.Box3(), Kt = new d.Vector2(), T = new d.Vector3(), k = new d.Vector3(), z = new d.Vector3(), P = new d.Vector2(), _ = new d.Vector3(), ot = new d.Matrix4(), at = new d.Matrix4(), Qt = 180, ct = 31, Jt = 64;
+function ht(g) {
   if (g !== void 0 && (!Number.isFinite(g) || g <= 0))
     throw new RangeError("SplatMesh maxStdDev must be a finite number greater than 0.");
   return g;
 }
-function Jt(g) {
+function te(g) {
   if (g !== void 0 && (!Number.isFinite(g) || g < 0))
     throw new RangeError("SplatMesh minSplatSizePx must be a finite number >= 0.");
   return g;
@@ -1918,25 +1950,25 @@ function H(g) {
     throw new RangeError("SplatMesh screen-radius cull must be a finite number ≥ 0.");
   return g;
 }
-const te = 1;
-function ee(g) {
-  if (g === void 0) return te;
+const ee = 1;
+function ie(g) {
+  if (g === void 0) return ee;
   if (!Number.isFinite(g) || g <= 0)
     throw new RangeError("SplatMesh foveationTargetPx must be a finite number > 0.");
   return g;
 }
-const ie = 9e5;
-function se(g) {
-  if (g === void 0) return ie;
+const se = 9e5;
+function re(g) {
+  if (g === void 0) return se;
   if (!Number.isFinite(g) || g <= 0)
     throw new RangeError("SplatMesh foveationDrawBudget must be a finite number > 0.");
   return g;
 }
 export {
-  ie as D,
+  se as D,
   nt as S,
-  te as a,
-  Ft as c,
-  Vt as y
+  ee as a,
+  Vt as c,
+  _t as y
 };
-//# sourceMappingURL=splat-mesh-CsLOQb08.js.map
+//# sourceMappingURL=splat-mesh-B1KlWHvx.js.map