@voluma/vlam 0.3.0 → 0.3.2

package/dist/streaming.js

@@ -1,55 +1,55 @@
 var Me = Object.defineProperty;
-var Fe = (o, i, e) => i in o ? Me(o, i, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[i] = e;
-var d = (o, i, e) => Fe(o, typeof i != "symbol" ? i + "" : i, e);
-import { h as Be, f as W, a as Ee, l as ke } from "./splat-budget-DuVZspPQ.js";
+var Fe = (o, s, e) => s in o ? Me(o, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[s] = e;
+var u = (o, s, e) => Fe(o, typeof s != "symbol" ? s + "" : s, e);
+import { h as Be, f as W, a as Pe, l as ke } from "./splat-budget-DuVZspPQ.js";
 import * as w from "three/webgpu";
-import { S as Pe, a as se, y as xe } from "./splat-mesh-aQdcWA6v.js";
+import { S as Ee, a as ie, y as xe } from "./splat-mesh-CsLOQb08.js";
 import { L as We, r as C } from "./lod-scheduler-B0a_uBlv.js";
-import { S as q, t as ee, r as Ae, i as G, a as _ } from "./loading-wLo8vRbA.js";
-import { y as Le } from "./relighting-CSQF3UcL.js";
+import { S as q, t as ee, r as Ae, i as N, a as _ } from "./loading-wLo8vRbA.js";
+import { y as Le } from "./relighting-Tiwep8yd.js";
 import { C as Ve } from "./chunk-loader-DlNwggfG.js";
 import { s as Ie } from "./sh-pack-D5wAe5gg.js";
-import { w as P } from "./logging-BfPdd7NJ.js";
-import { r as Ne, M as De, a as ne, i as j } from "./splat-mesh-types-BZIko-_9.js";
-const Ge = 32e3;
+import { w as E } from "./logging-BfPdd7NJ.js";
+import { r as De, M as Ge, a as ne, i as j } from "./splat-mesh-types-BZIko-_9.js";
+const Ne = 32e3;
 function _e(o) {
-  return o.map((i) => ({
-    adds: [i],
+  return o.map((s) => ({
+    adds: [s],
     removes: [],
-    leafStart: i.leafStart,
-    leafEnd: i.leafEnd,
-    addCount: i.count
-  })).sort((i, e) => i.leafStart - e.leafStart);
+    leafStart: s.leafStart,
+    leafEnd: s.leafEnd,
+    addCount: s.count
+  })).sort((s, e) => s.leafStart - e.leafStart);
 }
-function ze(o, i) {
-  const e = [...o, ...i.map(([, n]) => n.run)];
+function Oe(o, s) {
+  const e = [...o, ...s.map(([, n]) => n.run)];
   if (e.length > 0 && e.every((n) => n.coverageGroup !== void 0)) {
-    const n = /* @__PURE__ */ new Map(), r = (l) => {
+    const n = /* @__PURE__ */ new Map(), a = (l) => {
       let c = n.get(l);
       return c || (c = { adds: [], removes: [] }, n.set(l, c)), c;
     };
     for (const l of o)
-      r(l.coverageGroup).adds.push(l);
-    for (const l of i)
-      r(l[1].run.coverageGroup).removes.push(l);
-    const a = [];
+      a(l.coverageGroup).adds.push(l);
+    for (const l of s)
+      a(l[1].run.coverageGroup).removes.push(l);
+    const r = [];
     for (const l of n.values()) {
-      const c = /* @__PURE__ */ new Map(), h = (u, g) => `${u}:${g}`, f = (u, g) => {
-        const v = h(u, g);
+      const c = /* @__PURE__ */ new Map(), h = (d, g) => `${d}:${g}`, f = (d, g) => {
+        const v = h(d, g);
         let m = c.get(v);
-        return m || (m = { adds: [], removes: [], leafStart: u, leafEnd: g, addCount: 0 }, c.set(v, m)), m;
+        return m || (m = { adds: [], removes: [], leafStart: d, leafEnd: g, addCount: 0 }, c.set(v, m)), m;
       };
-      for (const u of l.adds) {
-        const g = f(u.leafStart, u.leafEnd);
-        g.adds.push(u), g.addCount += u.count;
+      for (const d of l.adds) {
+        const g = f(d.leafStart, d.leafEnd);
+        g.adds.push(d), g.addCount += d.count;
       }
-      for (const u of l.removes) {
-        const g = u[1].run, v = f(g.leafStart, g.leafEnd);
-        v.removes.push(u), v.leafStart = Math.min(v.leafStart, g.leafStart), v.leafEnd = Math.max(v.leafEnd, g.leafEnd);
+      for (const d of l.removes) {
+        const g = d[1].run, v = f(g.leafStart, g.leafEnd);
+        v.removes.push(d), v.leafStart = Math.min(v.leafStart, g.leafStart), v.leafEnd = Math.max(v.leafEnd, g.leafEnd);
       }
-      a.push(...c.values());
+      r.push(...c.values());
     }
-    return a.sort((l, c) => l.leafStart - c.leafStart);
+    return r.sort((l, c) => l.leafStart - c.leafStart);
   }
   const t = [
     ...o.map((n) => ({
@@ -58,53 +58,53 @@ function ze(o, i) {
       add: n,
       remove: void 0
     })),
-    ...i.map((n) => ({
+    ...s.map((n) => ({
       start: n[1].run.leafStart,
       end: n[1].run.leafEnd,
       add: void 0,
       remove: n
     }))
-  ].sort((n, r) => n.start - r.start || r.end - n.end), s = [];
+  ].sort((n, a) => n.start - a.start || a.end - n.end), i = [];
   for (const n of t) {
-    const r = s[s.length - 1];
-    (!r || n.start >= r.leafEnd) && s.push({
+    const a = i[i.length - 1];
+    (!a || n.start >= a.leafEnd) && i.push({
       adds: [],
       removes: [],
       leafStart: n.start,
       leafEnd: n.end,
       addCount: 0
     });
-    const a = s[s.length - 1];
-    a.leafEnd = Math.max(a.leafEnd, n.end), n.add && (a.adds.push(n.add), a.addCount += n.add.count), n.remove && a.removes.push(n.remove);
+    const r = i[i.length - 1];
+    r.leafEnd = Math.max(r.leafEnd, n.end), n.add && (r.adds.push(n.add), r.addCount += n.add.count), n.remove && r.removes.push(n.remove);
   }
-  return s;
+  return i;
 }
-function re(o) {
+function ae(o) {
   if (o.adds.length === 0) return 1e3;
-  const i = -Math.max(...o.adds.map((e) => e.level));
-  return o.removes.length === 0 ? -1e3 + i : i;
+  const s = -Math.max(...o.adds.map((e) => e.level));
+  return o.removes.length === 0 ? -1e3 + s : s;
 }
-function Oe(o) {
+function ze(o) {
   return o.length > 0 && o.every(
-    (i) => [...i.adds, ...i.removes.map(([, e]) => e.run)].every(
+    (s) => [...s.adds, ...s.removes.map(([, e]) => e.run)].every(
       (e) => e.coverageGroup !== void 0
     )
   );
 }
-function Ue(o, i) {
+function Ue(o, s) {
   const e = (n) => {
-    const r = [...n.adds, ...n.removes.map(([, a]) => a.run)];
+    const a = [...n.adds, ...n.removes.map(([, r]) => r.run)];
     return {
       removeOnly: n.adds.length === 0 ? 1 : 0,
-      view: r.some((a) => a.inView !== !1) ? 0 : 1,
-      finest: n.adds.some((a) => a.level === 0) ? 0 : 1,
-      screen: Math.min(...r.map((a) => a.screenImportance ?? Number.POSITIVE_INFINITY)),
-      distance: Math.min(...r.map((a) => a.distance ?? Number.POSITIVE_INFINITY))
+      view: a.some((r) => r.inView !== !1) ? 0 : 1,
+      finest: n.adds.some((r) => r.level === 0) ? 0 : 1,
+      screen: Math.min(...a.map((r) => r.screenImportance ?? Number.POSITIVE_INFINITY)),
+      distance: Math.min(...a.map((r) => r.distance ?? Number.POSITIVE_INFINITY))
     };
-  }, t = e(o), s = e(i);
-  return t.removeOnly - s.removeOnly || t.view - s.view || t.finest - s.finest || t.screen - s.screen || t.distance - s.distance || o.leafStart - i.leafStart;
+  }, t = e(o), i = e(s);
+  return t.removeOnly - i.removeOnly || t.view - i.view || t.finest - i.finest || t.screen - i.screen || t.distance - i.distance || o.leafStart - s.leafStart;
 }
-function ae(o) {
+function re(o) {
   switch (o) {
     case "environment":
       return -1;
@@ -121,72 +121,72 @@ function ae(o) {
 function He(o) {
   return o === "background" ? "base" : "priority";
 }
-function D(o, i) {
-  return o.coverageGroup < 0 ? `file:${i}` : o.phase === "finest-target" ? `cell:${o.coverageGroup}` : `slice:${o.coverageGroup}:${o.leafStart}:${o.leafEnd}`;
+function G(o, s) {
+  return o.coverageGroup < 0 ? `file:${s}` : o.phase === "finest-target" ? `cell:${o.coverageGroup}` : `slice:${o.coverageGroup}:${o.leafStart}:${o.leafEnd}`;
 }
-function $e(o, i = 10, e = !1) {
-  const t = te(i), s = /* @__PURE__ */ new Map();
-  for (const [n, r] of o) {
-    if (r.phase === "environment") continue;
-    const a = D(r, n), l = s.get(a);
+function $e(o, s = 10, e = !1) {
+  const t = te(s), i = /* @__PURE__ */ new Map();
+  for (const [n, a] of o) {
+    if (a.phase === "environment") continue;
+    const r = G(a, n), l = i.get(r);
     if (!l) {
-      s.set(a, {
-        distance: r.distance,
+      i.set(r, {
+        distance: a.distance,
         count: 1,
-        inView: r.inView,
-        screenImportance: r.screenImportance,
-        finest: r.phase === "finest-target"
+        inView: a.inView,
+        screenImportance: a.screenImportance,
+        finest: a.phase === "finest-target"
       });
       continue;
     }
-    r.distance < l.distance && (l.distance = r.distance), r.inView && (l.inView = !0), r.screenImportance < l.screenImportance && (l.screenImportance = r.screenImportance), r.phase === "finest-target" && (l.finest = !0), l.count++;
+    a.distance < l.distance && (l.distance = a.distance), a.inView && (l.inView = !0), a.screenImportance < l.screenImportance && (l.screenImportance = a.screenImportance), a.phase === "finest-target" && (l.finest = !0), l.count++;
   }
-  for (const [n, r] of o) {
-    if (r.phase === "environment") {
-      r.kind = "priority", r.groupDistance = 0, r.groupPending = 1, r.groupInView = !0, r.groupScreenImportance = Number.NEGATIVE_INFINITY, r.groupFinest = !0, r.groupId = "environment", r.groupClass = 0;
+  for (const [n, a] of o) {
+    if (a.phase === "environment") {
+      a.kind = "priority", a.groupDistance = 0, a.groupPending = 1, a.groupInView = !0, a.groupScreenImportance = Number.NEGATIVE_INFINITY, a.groupFinest = !0, a.groupId = "environment", a.groupClass = 0;
       continue;
     }
-    const a = D(r, n), l = s.get(a);
+    const r = G(a, n), l = i.get(r);
     if (!l) continue;
     const c = l.inView ? 0 : l.distance <= t ? 1 : 2, h = c === 0 || c === 1 && e ? "priority" : "base";
-    r.groupDistance = l.distance, r.groupPending = l.count, r.groupInView = l.inView, r.groupScreenImportance = l.screenImportance, r.groupFinest = l.finest, r.groupId = a, r.groupClass = c, r.kind = h;
+    a.groupDistance = l.distance, a.groupPending = l.count, a.groupInView = l.inView, a.groupScreenImportance = l.screenImportance, a.groupFinest = l.finest, a.groupId = r, a.groupClass = c, a.kind = h;
   }
 }
-function te(o, i = 2) {
+function te(o, s = 2) {
   return o;
 }
 function Ye(o) {
-  return o.adds.some((i) => i.level === 0);
+  return o.adds.some((s) => s.level === 0);
 }
-function qe(o, i, e = 2) {
+function qe(o, s, e = 2) {
   if (o.level === 0) return "finest-target";
   const t = o.distance ?? Number.POSITIVE_INFINITY;
-  return o.inView === !1 && t > te(i) ? "background" : "target";
+  return o.inView === !1 && t > te(s) ? "background" : "target";
 }
-function je(o, i, e = 2) {
+function je(o, s, e = 2) {
   const t = o.distance ?? Number.POSITIVE_INFINITY;
-  return o.inView === !1 && t > te(i) ? "background" : "coverage";
+  return o.inView === !1 && t > te(s) ? "background" : "coverage";
 }
-function oe(o, i, e, t) {
-  const s = t.distance ?? Number.POSITIVE_INFINITY, n = t.level, r = t.inView !== !1, a = t.coverageGroup ?? -1, l = t.screenImportance ?? Number.POSITIVE_INFINITY, c = He(e), h = o.get(i);
+function oe(o, s, e, t) {
+  const i = t.distance ?? Number.POSITIVE_INFINITY, n = t.level, a = t.inView !== !1, r = t.coverageGroup ?? -1, l = t.screenImportance ?? Number.POSITIVE_INFINITY, c = He(e), h = o.get(s);
   if (!h) {
-    const v = D(
-      { phase: e, coverageGroup: a, leafStart: t.leafStart, leafEnd: t.leafEnd },
-      i
+    const v = G(
+      { phase: e, coverageGroup: r, leafStart: t.leafStart, leafEnd: t.leafEnd },
+      s
     );
-    o.set(i, {
+    o.set(s, {
       kind: c,
       phase: e,
-      distance: s,
+      distance: i,
       level: n,
-      inView: r,
-      coverageGroup: a,
+      inView: a,
+      coverageGroup: r,
       leafStart: t.leafStart,
       leafEnd: t.leafEnd,
       screenImportance: l,
-      groupDistance: s,
+      groupDistance: i,
       groupPending: 1,
-      groupInView: r,
+      groupInView: a,
       groupScreenImportance: l,
       groupFinest: e === "finest-target",
       groupId: v,
@@ -195,41 +195,41 @@ function oe(o, i, e, t) {
     });
     return;
   }
-  const f = ae(e) < ae(h.phase), u = e === h.phase && (s < h.distance || s === h.distance && n < h.level), g = e === h.phase && s === h.distance && n === h.level && r && !h.inView;
-  (f || u || g) && o.set(i, {
+  const f = re(e) < re(h.phase), d = e === h.phase && (i < h.distance || i === h.distance && n < h.level), g = e === h.phase && i === h.distance && n === h.level && a && !h.inView;
+  (f || d || g) && o.set(s, {
     kind: c,
     phase: e,
-    distance: s,
+    distance: i,
     level: n,
-    inView: r || h.inView,
-    coverageGroup: a >= 0 ? a : h.coverageGroup,
+    inView: a || h.inView,
+    coverageGroup: r >= 0 ? r : h.coverageGroup,
     leafStart: t.leafStart,
     leafEnd: t.leafEnd,
     screenImportance: l,
-    groupDistance: Math.min(s, h.groupDistance),
+    groupDistance: Math.min(i, h.groupDistance),
     groupPending: h.groupPending,
-    groupInView: r || h.groupInView,
+    groupInView: a || h.groupInView,
     groupScreenImportance: Math.min(l, h.groupScreenImportance),
     groupFinest: e === "finest-target" || h.groupFinest,
     groupId: h.groupId,
     groupClass: h.groupClass
   });
 }
-function X(o, i, e, t) {
-  const s = o.groupDistance ?? o.distance, n = i.groupDistance ?? i.distance, r = o.groupPending ?? 1, a = i.groupPending ?? 1, l = o.groupId ?? D(o, e), c = i.groupId ?? D(i, t), h = o.groupClass ?? (o.inView ? 0 : 2), f = i.groupClass ?? (i.inView ? 0 : 2), u = o.groupScreenImportance ?? o.screenImportance, g = i.groupScreenImportance ?? i.screenImportance, v = o.groupFinest ? 0 : 1, m = i.groupFinest ? 0 : 1, b = (y) => y === "coverage" ? 0 : y === "background" ? 2 : 1, T = o.phase === "environment" ? 0 : 1, I = i.phase === "environment" ? 0 : 1;
-  return T - I || h - f || v - m || u - g || s - n || a - r || (l < c ? -1 : l > c ? 1 : 0) || b(o.phase) - b(i.phase) || o.level - i.level || e - t;
+function X(o, s, e, t) {
+  const i = o.groupDistance ?? o.distance, n = s.groupDistance ?? s.distance, a = o.groupPending ?? 1, r = s.groupPending ?? 1, l = o.groupId ?? G(o, e), c = s.groupId ?? G(s, t), h = o.groupClass ?? (o.inView ? 0 : 2), f = s.groupClass ?? (s.inView ? 0 : 2), d = o.groupScreenImportance ?? o.screenImportance, g = s.groupScreenImportance ?? s.screenImportance, v = o.groupFinest ? 0 : 1, m = s.groupFinest ? 0 : 1, b = (y) => y === "coverage" ? 0 : y === "background" ? 2 : 1, T = o.phase === "environment" ? 0 : 1, I = s.phase === "environment" ? 0 : 1;
+  return T - I || h - f || v - m || d - g || i - n || r - a || (l < c ? -1 : l > c ? 1 : 0) || b(o.phase) - b(s.phase) || o.level - s.level || e - t;
 }
-function K(o, i, e) {
-  if (i < 0 || e < 0 || i + e > o.count)
+function K(o, s, e) {
+  if (s < 0 || e < 0 || s + e > o.count)
     throw new Error(
-      `Splat range [${i}, ${i + e}) exceeds its chunk's ${o.count} splats; the manifest and chunk data disagree.`
+      `Splat range [${s}, ${s + e}) exceeds its chunk's ${o.count} splats; the manifest and chunk data disagree.`
     );
   const t = o.shPacked;
   return {
     count: e,
-    positions: o.positions.subarray(i * 3, (i + e) * 3),
-    colors: o.colors.subarray(i * 4, (i + e) * 4),
-    covariances: o.covariances.subarray(i * 6, (i + e) * 6),
+    positions: o.positions.subarray(s * 3, (s + e) * 3),
+    colors: o.colors.subarray(s * 4, (s + e) * 4),
+    covariances: o.covariances.subarray(s * 6, (s + e) * 6),
     // Per-splat SH is splat-major, so it slices like everything else. Palette
     // shN (`chunk.sh`) is deliberately not carried: its labels index a
     // per-file codebook the shared pool has no way to hold.
@@ -237,45 +237,45 @@ function K(o, i, e) {
       shPacked: {
         ...t,
         packed: t.packed.subarray(
-          i * le(t.bands),
-          (i + e) * le(t.bands)
+          s * le(t.bands),
+          (s + e) * le(t.bands)
         )
       }
     } : {},
     // Per-splat frontier `parent_size` (foveated `.rad`) slices splat-major like
     // the rest; uploaded into `covarianceB.w` by the pool.
-    ...o.frontierParent ? { frontierParent: o.frontierParent.subarray(i, i + e) } : {}
+    ...o.frontierParent ? { frontierParent: o.frontierParent.subarray(s, s + e) } : {}
   };
 }
 function le(o) {
   return o === 1 ? 3 : o === 2 ? 8 : 15;
 }
 function Xe(o) {
-  var i;
+  var s;
   return o.positions.byteLength + o.colors.byteLength + o.covariances.byteLength + // SH is the largest part of an LCC Quality chunk (64 B/splat against the
   // base 32); omitting it would let the CPU cache run ~3x over its cap.
-  (((i = o.shPacked) == null ? void 0 : i.packed.byteLength) ?? 0);
+  (((s = o.shPacked) == null ? void 0 : s.packed.byteLength) ?? 0);
 }
 function Ke(o) {
-  const i = o.reason;
-  return i instanceof Error ? i : new DOMException("Aborted", "AbortError");
+  const s = o.reason;
+  return s instanceof Error ? s : new DOMException("Aborted", "AbortError");
 }
 function Qe(o) {
-  const i = o ?? Ge;
-  if (!Number.isInteger(i) || i <= 0)
+  const s = o ?? Ne;
+  if (!Number.isInteger(s) || s <= 0)
     throw new RangeError("StreamedSplatMesh maxSplatsPerSwap must be a positive integer.");
-  return i;
+  return s;
 }
 function ce(o) {
-  const i = o ?? 1;
-  if (!Number.isFinite(i) || i <= 0)
+  const s = o ?? 1;
+  if (!Number.isFinite(s) || s <= 0)
     throw new RangeError("StreamedSplatMesh lodScale must be a positive finite number.");
-  return i;
+  return s;
 }
 function Je() {
   return Be();
 }
-function Ze(o, i) {
+function Ze(o, s) {
   const e = o;
   if (typeof e != "object" || e === null)
     throw new Error("Streamed SOG manifest is not a JSON object.");
@@ -287,39 +287,39 @@ function Ze(o, i) {
     throw new Error('Streamed SOG manifest "counts" must be an array of non-negative integers.');
   if (!Number.isSafeInteger(e.lodLevels) || e.lodLevels < 1 || e.lodLevels > 64)
     throw new Error(`Streamed SOG manifest declares an invalid lodLevels: ${e.lodLevels}.`);
-  const t = e.filenames.map((l) => l.replace(/\/?meta\.json$/, "/")), s = t.map(
-    (l) => i.resolve(l) ?? `${i.manifestUrl}#${l}`
-  ), n = [], r = e.lodLevels, a = [e.tree];
-  for (; a.length > 0; ) {
-    const l = a.pop();
+  const t = e.filenames.map((l) => l.replace(/\/?meta\.json$/, "/")), i = t.map(
+    (l) => s.resolve(l) ?? `${s.manifestUrl}#${l}`
+  ), n = [], a = e.lodLevels, r = [e.tree];
+  for (; r.length > 0; ) {
+    const l = r.pop();
     if (typeof l != "object" || l === null)
       throw new Error("Streamed SOG manifest tree contains a malformed node.");
     if (l.children) {
       if (!Array.isArray(l.children) || l.children.length !== 2)
         throw new Error("Streamed SOG manifest tree node must have exactly two children.");
-      a.push(l.children[1], l.children[0]);
+      r.push(l.children[1], l.children[0]);
       continue;
     }
-    const c = new Array(r).fill(
+    const c = new Array(a).fill(
       void 0
     );
     for (const [h, f] of Object.entries(l.lods ?? {})) {
-      const u = Number(h);
-      u >= 0 && u < r && (et(f, e.filenames.length), c[u] = f);
+      const d = Number(h);
+      d >= 0 && d < a && (et(f, e.filenames.length), c[d] = f);
     }
     n.push({ bounds: he(l.bound), lods: c });
   }
   return {
     leaves: n,
-    chunkUrls: s,
+    chunkUrls: i,
     chunkDirectories: t,
     counts: e.counts,
-    lodLevels: r,
+    lodLevels: a,
     bounds: he(e.tree.bound)
   };
 }
-function et(o, i) {
-  if (typeof o != "object" || o === null || !Number.isSafeInteger(o.file) || o.file < 0 || o.file >= i || !Number.isSafeInteger(o.offset) || o.offset < 0 || !Number.isSafeInteger(o.count) || o.count < 0)
+function et(o, s) {
+  if (typeof o != "object" || o === null || !Number.isSafeInteger(o.file) || o.file < 0 || o.file >= s || !Number.isSafeInteger(o.offset) || o.offset < 0 || !Number.isSafeInteger(o.count) || o.count < 0)
     throw new Error(
       `Streamed SOG manifest leaf declares an invalid LOD range (file ${o == null ? void 0 : o.file}, offset ${o == null ? void 0 : o.offset}, count ${o == null ? void 0 : o.count}).`
     );
@@ -330,10 +330,10 @@ function he(o) {
     new w.Vector3(o.max[0], o.max[1], o.max[2])
   );
 }
-function tt(o, i, e, t = 0) {
-  const s = Ze(o, i), n = t >= 1 ? t : void 0, r = s.chunkUrls.map((a, l) => {
+function tt(o, s, e, t = 0) {
+  const i = Ze(o, s), n = t >= 1 ? t : void 0, a = i.chunkUrls.map((r, l) => {
     var f;
-    const c = (f = s.chunkDirectories) == null ? void 0 : f[l], h = c ? i.directoryFiles(c) : null;
+    const c = (f = i.chunkDirectories) == null ? void 0 : f[l], h = c ? s.directoryFiles(c) : null;
     if (!(!h && !n))
       return {
         format: "sog",
@@ -342,86 +342,86 @@ function tt(o, i, e, t = 0) {
       };
   });
   return {
-    source: new We(s, e),
-    chunkUrls: s.chunkUrls,
-    ...r.some(Boolean) ? { chunkOptions: r } : {},
+    source: new We(i, e),
+    chunkUrls: i.chunkUrls,
+    ...a.some(Boolean) ? { chunkOptions: a } : {},
     ...n ? { shBands: n } : {},
     chunkKind: "directory",
     // Streamed SOG chunks are unbundled directories
-    bounds: s.bounds,
-    pinnedFiles: st(s),
-    maxResidentSplats: s.counts[0] ?? e.budget,
-    minimumCoverageSplats: it(s)
+    bounds: i.bounds,
+    pinnedFiles: it(i),
+    maxResidentSplats: i.counts[0] ?? e.budget,
+    minimumCoverageSplats: st(i)
   };
 }
-function it(o) {
-  let i = 0;
+function st(o) {
+  let s = 0;
   for (const e of o.leaves)
     for (let t = e.lods.length - 1; t >= 0; t--) {
-      const s = e.lods[t];
-      if (s) {
-        i += s.count;
+      const i = e.lods[t];
+      if (i) {
+        s += i.count;
         break;
       }
     }
-  return Math.max(1, i);
+  return Math.max(1, s);
 }
-function st(o) {
-  const i = /* @__PURE__ */ new Set();
+function it(o) {
+  const s = /* @__PURE__ */ new Set();
   for (const e of o.leaves)
     for (let t = e.lods.length - 1; t >= 0; t--) {
-      const s = e.lods[t];
-      if (s) {
-        i.add(s.file);
+      const i = e.lods[t];
+      if (i) {
+        s.add(i.file);
         break;
       }
     }
-  return i;
+  return s;
 }
-function nt(o, i) {
+function nt(o, s) {
   return {
     manifestUrl: o,
     resolve: (e) => new URL(e, o).href,
-    size: (e) => rt(new URL(e, o).href, i),
+    size: (e) => at(new URL(e, o).href, s),
     directoryFiles: () => null,
     dispose: () => {
     }
   };
 }
-async function rt(o, i) {
+async function at(o, s) {
   var e;
   try {
-    const t = await fetch(o, { ...ee(i), method: "HEAD" });
-    if (await ue(t), t.ok) {
-      const s = t.headers.get("content-length");
-      if (s !== null) return de(Number(s));
+    const t = await fetch(o, { ...ee(s), method: "HEAD" });
+    if (await de(t), t.ok) {
+      const i = t.headers.get("content-length");
+      if (i !== null) return ue(Number(i));
     } else if (t.status === 404)
       return null;
   } catch {
   }
   try {
     const t = await fetch(o, {
-      ...ee(i),
-      headers: { ...(i == null ? void 0 : i.headers) ?? {}, Range: "bytes=0-0" }
+      ...ee(s),
+      headers: { ...(s == null ? void 0 : s.headers) ?? {}, Range: "bytes=0-0" }
     });
-    if (await ue(t), t.status !== 206) return null;
-    const s = (e = t.headers.get("content-range")) == null ? void 0 : e.split("/")[1];
-    return s === void 0 || s === "*" ? null : de(Number(s));
+    if (await de(t), t.status !== 206) return null;
+    const i = (e = t.headers.get("content-range")) == null ? void 0 : e.split("/")[1];
+    return i === void 0 || i === "*" ? null : ue(Number(i));
   } catch {
     return null;
   }
 }
-async function ue(o) {
-  var i;
+async function de(o) {
+  var s;
   try {
-    await ((i = o.body) == null ? void 0 : i.cancel());
+    await ((s = o.body) == null ? void 0 : s.cancel());
   } catch {
   }
 }
-function de(o) {
+function ue(o) {
   return Number.isSafeInteger(o) && o >= 0 ? o : null;
 }
-const at = [
+const rt = [
   { test: (o) => o.endsWith(".lcc2"), format: "lcc2" },
   { test: (o) => o.endsWith(".lcc"), format: "lcc" },
   // The `.rad` header of a `--rad-chunked` set; `.radc` chunk files are not
@@ -430,40 +430,40 @@ const at = [
   { test: (o) => o === "lod-meta.json", format: "streamed-sog" }
 ];
 function ot(o) {
-  const i = [];
-  for (const a of o.keys()) {
-    const l = $(a).toLowerCase(), c = at.find((h) => h.test(l));
-    c && Re(a) === lt(o, c) && i.push({ path: a, format: c.format });
+  const s = [];
+  for (const r of o.keys()) {
+    const l = $(r).toLowerCase(), c = rt.find((h) => h.test(l));
+    c && Re(r) === lt(o, c) && s.push({ path: r, format: c.format });
   }
-  if (i.length === 0)
+  if (s.length === 0)
     throw new q(
       "That folder has no streamed-scene manifest in it (expected a .lcc, .lcc2 or lod-meta.json file).",
       { phase: "manifest", url: "local-folder", retryable: !1 }
     );
-  if (i.length > 1) {
-    const a = i.map((l) => $(l.path)).join(", ");
+  if (s.length > 1) {
+    const r = s.map((l) => $(l.path)).join(", ");
     throw new q(
-      `That folder holds more than one scene manifest (${a}) - drop one scene at a time.`,
+      `That folder holds more than one scene manifest (${r}) - drop one scene at a time.`,
       { phase: "manifest", url: "local-folder", retryable: !1 }
     );
   }
-  const e = i[0], t = e.path.includes("/") ? e.path.slice(0, e.path.lastIndexOf("/") + 1) : "", s = /* @__PURE__ */ new Map(), n = (a) => {
-    const l = s.get(a);
+  const e = s[0], t = e.path.includes("/") ? e.path.slice(0, e.path.lastIndexOf("/") + 1) : "", i = /* @__PURE__ */ new Map(), n = (r) => {
+    const l = i.get(r);
     if (l !== void 0) return l;
-    const c = o.get(a);
+    const c = o.get(r);
     if (!c) return null;
     const h = URL.createObjectURL(c);
-    return s.set(a, h), h;
+    return i.set(r, h), h;
   };
   return { source: {
     manifestUrl: n(e.path),
-    resolve: (a) => n(t + Q(a)),
-    size: (a) => {
+    resolve: (r) => n(t + Q(r)),
+    size: (r) => {
       var l;
-      return Promise.resolve(((l = o.get(t + Q(a))) == null ? void 0 : l.size) ?? null);
+      return Promise.resolve(((l = o.get(t + Q(r))) == null ? void 0 : l.size) ?? null);
     },
-    directoryFiles: (a) => {
-      const l = t + Q(a).replace(/\/?$/, "/"), c = {};
+    directoryFiles: (r) => {
+      const l = t + Q(r).replace(/\/?$/, "/"), c = {};
       for (const h of o.keys()) {
         if (!h.startsWith(l)) continue;
         const f = n(h);
@@ -472,8 +472,8 @@ function ot(o) {
       return Object.keys(c).length > 0 ? c : null;
     },
     dispose: () => {
-      for (const a of s.values()) URL.revokeObjectURL(a);
-      s.clear();
+      for (const r of i.values()) URL.revokeObjectURL(r);
+      i.clear();
     }
   }, format: e.format, name: $(e.path) };
 }
@@ -486,10 +486,10 @@ function $(o) {
 function Re(o) {
   return o.split("/").length - 1;
 }
-function lt(o, i) {
+function lt(o, s) {
   let e = 1 / 0;
   for (const t of o.keys())
-    i.test($(t).toLowerCase()) && (e = Math.min(e, Re(t)));
+    s.test($(t).toLowerCase()) && (e = Math.min(e, Re(t)));
   return e;
 }
 const fe = {
@@ -497,17 +497,17 @@ const fe = {
   coneFov: 120,
   coneFoveate: 0.4,
   behindFoveate: 0.2
-}, F = 2048, ct = 6e4, ht = 0.25, ut = 8, dt = 600, ft = 250, gt = 4, pt = 500, mt = 3, vt = 4e6, ge = 65536, St = 2 * 1024 * 1024 * 1024;
+}, F = 2048, ct = 6e4, ht = 0.25, dt = 8, ut = 600, ft = 250, gt = 4, pt = 500, mt = 3, vt = 4e6, ge = 65536, St = 2 * 1024 * 1024 * 1024;
 function bt(o) {
-  const i = 52 + (o.shBands ? 16 * Math.ceil(Ie(o.shBands) / 4) : 0), t = (o.chunkSize === void 0 ? void 0 : o.chunkSize * o.chunkUrls.length) ?? o.contentSplatCount ?? o.maxResidentSplats;
-  return Math.max(1, t) * i;
+  const s = 52 + (o.shBands ? 16 * Math.ceil(Ie(o.shBands) / 4) : 0), t = (o.chunkSize === void 0 ? void 0 : o.chunkSize * o.chunkUrls.length) ?? o.contentSplatCount ?? o.maxResidentSplats;
+  return Math.max(1, t) * s;
 }
-class Y extends Pe {
-  constructor(e, t, s, n, r, a = !1) {
-    var u, g, v;
-    super({ capacity: s }, n);
-    d(this, "scene");
-    d(this, "loader", new Ve());
+class Y extends Ee {
+  constructor(e, t, i, n, a, r = !1) {
+    var d, g, v;
+    super({ capacity: i }, n);
+    u(this, "scene");
+    u(this, "loader", new Ve());
     /**
      * Cap the *classic* (non-page-table) chunk cache evicts against.
      *
@@ -515,67 +515,67 @@ class Y extends Pe {
      * moves; without a budget it stays at the value `options.cpuCacheBytes` or the
      * device default set at construction.
      */
-    d(this, "cpuCacheBytes");
-    d(this, "budgetValue");
-    d(this, "maximumBudget");
+    u(this, "cpuCacheBytes");
+    u(this, "budgetValue");
+    u(this, "maximumBudget");
     /** Spark's per-mesh `lodScale`; divides the page-table cut limit. */
-    d(this, "lodScaleValue");
+    u(this, "lodScaleValue");
     /** Set once the governed budget has been reported as exceeding an explicit
      * `foveationDrawBudget`, so the warning is issued at most once. */
-    d(this, "warnedDrawTargetCap", !1);
-    d(this, "stagedSwapsEnabled");
+    u(this, "warnedDrawTargetCap", !1);
+    u(this, "stagedSwapsEnabled");
     /** Classic LCC must keep old cell coverage while a replacement is pending. */
-    d(this, "neverRetireCoverageEarly");
-    d(this, "appendCap");
-    d(this, "onPerformanceEvent");
-    d(this, "compactionCount", 0);
-    d(this, "cache", /* @__PURE__ */ new Map());
+    u(this, "neverRetireCoverageEarly");
+    u(this, "appendCap");
+    u(this, "onPerformanceEvent");
+    u(this, "compactionCount", 0);
+    u(this, "cache", /* @__PURE__ */ new Map());
     /** Running byte total of {@link cache}; maintained by {@link cacheChunk}, eviction and dispose. */
-    d(this, "cacheBytesTotal", 0);
+    u(this, "cacheBytesTotal", 0);
     /** In-flight chunk fetches. The kind is kept so a weight change can shed the
      * speculative ones without touching the detail that is actually on screen. */
-    d(this, "fetching", /* @__PURE__ */ new Map());
+    u(this, "fetching", /* @__PURE__ */ new Map());
     /** This mesh's camera-projected share of the scene's fetch bandwidth. */
-    d(this, "fetchWeight");
+    u(this, "fetchWeight");
     /** Scene-wide fetch arbitration, when the host shares one; see `requestChunk`. */
-    d(this, "fetchScheduler");
-    d(this, "fetchHandle");
+    u(this, "fetchScheduler");
+    u(this, "fetchHandle");
     /**
      * Blob-URL dataset from {@link loadLocal}, owned by this mesh so its object
      * URLs are revoked on {@link dispose} rather than leaking for the document's
      * lifetime. Undefined for every network-loaded mesh.
      */
-    d(this, "localSource");
+    u(this, "localSource");
     /** Scene-wide chunk-cache ceiling, when the host shares one. */
-    d(this, "cacheBudget");
-    d(this, "cacheBudgetHandle");
+    u(this, "cacheBudget");
+    u(this, "cacheBudgetHandle");
     /**
      * The cap this mesh's frontier worker is currently evicting against.
      *
      * Mirrored on the main thread so `applyCacheAllowance` can skip no-op posts
      * and so `fetchCounts.cacheLimitBytes` stays truthful between plans.
      */
-    d(this, "cacheLimitBytes", 0);
-    d(this, "resident", /* @__PURE__ */ new Map());
+    u(this, "cacheLimitBytes", 0);
+    u(this, "resident", /* @__PURE__ */ new Map());
     /** Replacement runs hidden while their pool data is uploaded in bounded segments. */
-    d(this, "staged", /* @__PURE__ */ new Map());
+    u(this, "staged", /* @__PURE__ */ new Map());
     /** Files awaiting a backoff retry after a transient fetch/decode error. */
-    d(this, "retrying", /* @__PURE__ */ new Map());
+    u(this, "retrying", /* @__PURE__ */ new Map());
     /** Files given up on after {@link MAX_CHUNK_ATTEMPTS} failures. */
-    d(this, "failedFiles", /* @__PURE__ */ new Set());
+    u(this, "failedFiles", /* @__PURE__ */ new Set());
     /**
      * When true, each resident run writes its LOD `level` into the `lodLevel`
      * float channel for false-color debug modifiers.
      */
-    d(this, "lodLevelDebug", !1);
-    d(this, "lodLevelChannelReady", !1);
-    d(this, "lodLevelScratch");
+    u(this, "lodLevelDebug", !1);
+    u(this, "lodLevelChannelReady", !1);
+    u(this, "lodLevelScratch");
     /** Desired-but-not-resident files this tick; protected from cache eviction. */
-    d(this, "neededFiles", /* @__PURE__ */ new Set());
+    u(this, "neededFiles", /* @__PURE__ */ new Set());
     /** Non-null in `foveationMode: 'page-table'`: the worker that owns the chunk
      * cache + traversal + pager off the main thread, and the always-active slab it
      * pages the returned frontier into. */
-    d(this, "frontierWorker");
+    u(this, "frontierWorker");
     /**
      * The frontier's slots, as a list of equally sized pages rather than one
      * contiguous run.
@@ -588,15 +588,15 @@ class Y extends Pe {
      * (Spark's pager does the same thing one level down, binding fixed pages to
      * `(source, chunk)` pairs.)
      */
-    d(this, "slabPages", []);
+    u(this, "slabPages", []);
     /** Most slots the slab may ever hold - the construction capacity. */
-    d(this, "slabCeiling", 0);
+    u(this, "slabCeiling", 0);
     /** Slot count the worker's pager was last told about. */
-    d(this, "pagerSlots", 0);
+    u(this, "pagerSlots", 0);
     /** Consecutive ticks the wave gate has held retirements back. */
-    d(this, "retireHeldTicks", 0);
+    u(this, "retireHeldTicks", 0);
     /** Backing store for {@link planTimings}. */
-    d(this, "planTimingsValue", {
+    u(this, "planTimingsValue", {
       applyMs: 0,
       worstApplyMs: 0,
       writeMs: 0,
@@ -610,7 +610,7 @@ class Y extends Pe {
      * they answer is about a *steady state* - "this keeps streaming after the view
      * settled" - which a per-frame or windowed number cannot express.
      */
-    d(this, "fetchCountsValue", {
+    u(this, "fetchCountsValue", {
       priority: 0,
       base: 0,
       sweep: 0,
@@ -626,46 +626,55 @@ class Y extends Pe {
      * with the solved frontier cut and always relative to the original - scaling
      * the live values repeatedly would drift. Null when the scene has no band.
      */
-    d(this, "frontierBandBase", null);
+    u(this, "frontierBandBase", null);
     /**
      * Splats per slab page for this mesh: {@link SLAB_PAGE_SPLATS}, or the whole
      * capacity when that is smaller. Spark can use one fixed page size because
      * its pool is a single large arena; here a mesh may be smaller than a page,
      * and rounding it up to one would waste most of the reservation.
      */
-    d(this, "slabPageSplats", ge);
+    u(this, "slabPageSplats", ge);
     /** Target drawn-splat count for the page-table frontier; see the constructor. */
-    d(this, "pageTableDrawBudget", 0);
+    u(this, "pageTableDrawBudget", 0);
     /** The unclamped draw target (`foveationDrawBudget` or the default), kept so
      * `setBudget` can re-derive the effective draw budget when the pool budget
      * moves (e.g. under a `BudgetGovernor`). */
-    d(this, "pageTableDrawTarget", 0);
+    u(this, "pageTableDrawTarget", 0);
     /** Whether {@link pageTableDrawTarget} came from an explicit
      * `foveationDrawBudget` - a caller-chosen hard cap worth warning about when a
      * governed budget outgrows it, rather than the library's own default. */
-    d(this, "pageTableDrawTargetExplicit", !1);
+    u(this, "pageTableDrawTargetExplicit", !1);
     /** Last frontier's drawn (non-degenerate) splat count - the true on-screen size
      * in `page-table` mode, where the slab is fully "active" but mostly degenerate. */
-    d(this, "pageTableDrawn", 0);
+    u(this, "pageTableDrawn", 0);
+    u(this, "frontierConverged", !0);
+    u(this, "pendingFrontierSplats", 0);
+    u(this, "staleResidentSplats", 0);
+    u(this, "lastPlanAppends", 0);
+    u(this, "lastPlanMoves", 0);
+    u(this, "lastPlanGeneration", 0);
+    u(this, "lastPlanBudget", 0);
+    u(this, "lastPlanCamera", null);
+    u(this, "firstFrontierCamera", null);
     /** Monotonic reschedule id; a stale plan (superseded by a newer request) is
      * dropped. `pageTableInFlight` coalesces to one outstanding traversal. */
-    d(this, "pageTableSeq", 0);
-    d(this, "pageTableInFlight", !1);
-    d(this, "pageTableDisposed", !1);
+    u(this, "pageTableSeq", 0);
+    u(this, "pageTableInFlight", !1);
+    u(this, "pageTableDisposed", !1);
     /** Files whose data has been forwarded to the worker (so we don't refetch). */
-    d(this, "pageTableCachedFiles", /* @__PURE__ */ new Set());
+    u(this, "pageTableCachedFiles", /* @__PURE__ */ new Set());
     /** Chunks the last frontier wanted but did not have, biggest-on-screen first.
      * These outrank the background sweep - they are the detail actually on screen. */
-    d(this, "pageTableFetchPriority", []);
+    u(this, "pageTableFetchPriority", []);
     /** Frontier-cut target node size (px) and foveation ramp; see `frontierView`. */
-    d(this, "pageTableTargetPx", se);
-    d(this, "pageTableFoveation", fe);
+    u(this, "pageTableTargetPx", ie);
+    u(this, "pageTableFoveation", fe);
     /** Drawing-buffer height, sampled in `update` so `reschedule` can derive the
      * cut limit the same way the material does (`targetPx / focalY`). */
-    d(this, "pageTableViewportY", 0);
+    u(this, "pageTableViewportY", 0);
     /** Frontier cut on foveated `size / distance`. Re-derived each reschedule once
      * the drawing buffer is known; the initial value only covers the first frame. */
-    d(this, "pageTableLimit", 0.02);
+    u(this, "pageTableLimit", 0.02);
     /**
      * Whether the worker's cache is sitting at its cap: sweeping past that point
      * only evicts what the frontier is using.
@@ -677,51 +686,51 @@ class Y extends Pe {
      * and is trimmed - and latching would kill its sweep for the session, so a
      * mesh that went cold could never re-warm when the camera returned.
      */
-    d(this, "pageTableCacheAtLimit", !1);
+    u(this, "pageTableCacheAtLimit", !1);
     /** Per-splat channels whose edits survive chunk eviction/reload (M7.6). */
-    d(this, "persistentChannels", /* @__PURE__ */ new Map());
+    u(this, "persistentChannels", /* @__PURE__ */ new Map());
     /** Chunk-file index of the always-resident environment tile, if the scene ships one. */
-    d(this, "envFile");
+    u(this, "envFile");
     /** Whether the environment tile should be visible; toggled live. */
-    d(this, "envEnabled");
+    u(this, "envEnabled");
     /** Pool handle of the environment tile once it has loaded (kept for toggling). */
-    d(this, "envHandle");
+    u(this, "envHandle");
     /** Env splat count, measured when the tile decodes; 0 until then. */
-    d(this, "envSplatCount", 0);
+    u(this, "envSplatCount", 0);
     /** Set when the env tile is larger than the whole pool - terminal, warned once. */
-    d(this, "envUnfit", !1);
+    u(this, "envUnfit", !1);
     /**
      * Startup hold. `'capture'` waits for the first schedule after the host
      * applies the final camera; `'holding'` freezes that coverage set.
      */
-    d(this, "initialRevealPhase", "off");
+    u(this, "initialRevealPhase", "off");
     /** Which hold, if any, was armed at construction. Survives release for recapture. */
-    d(this, "initialRevealHold", "off");
+    u(this, "initialRevealHold", "off");
     /** Frozen nearby-detail / in-view coverage runs for {@link initialRevealPhase} `'holding'`. */
-    d(this, "frozenCriticalRuns", null);
+    u(this, "frozenCriticalRuns", null);
     /** Timestamp of the final-camera capture that began the current hold. */
-    d(this, "initialRevealStartedAt");
-    d(this, "initialRevealStateValue", { status: "disabled" });
+    u(this, "initialRevealStartedAt");
+    u(this, "initialRevealStateValue", { status: "disabled" });
     /** Fetch settings this mesh was loaded with, reused for collision meshes. */
-    d(this, "requestOptions");
+    u(this, "requestOptions");
     /** In-flight or settled collision load; see {@link loadCollisionMeshes}. */
-    d(this, "collisionTiles");
-    d(this, "collisionAbort");
-    d(this, "pendingWork", !0);
-    d(this, "lastScheduleTime", -1 / 0);
+    u(this, "collisionTiles");
+    u(this, "collisionAbort");
+    u(this, "pendingWork", !0);
+    u(this, "lastScheduleTime", -1 / 0);
     /** Reused leaf-coverage bitmap for {@link substituteCoverage}; grows only. */
-    d(this, "coverageScratch");
-    d(this, "lastCameraPos", new w.Vector3(1 / 0, 1 / 0, 1 / 0));
-    d(this, "lastCameraQuat", new w.Quaternion());
-    this.scene = e, this.budgetValue = t, this.maximumBudget = n.maxBudget === void 0 ? t : Math.max(t, W(n.maxBudget)), this.lodScaleValue = ce(n.lodScale), this.stagedSwapsEnabled = n.experimentalStagedSwaps !== !1, this.neverRetireCoverageEarly = a, this.appendCap = Qe(n.maxSplatsPerSwap);
-    const l = n.initialReveal === "hold-coverage" && this.scene.source.coverageRunsFor !== void 0, c = n.initialReveal === "hold-near-l0" && a;
+    u(this, "coverageScratch");
+    u(this, "lastCameraPos", new w.Vector3(1 / 0, 1 / 0, 1 / 0));
+    u(this, "lastCameraQuat", new w.Quaternion());
+    this.scene = e, this.budgetValue = t, this.maximumBudget = n.maxBudget === void 0 ? t : Math.max(t, W(n.maxBudget)), this.lodScaleValue = ce(n.lodScale), this.stagedSwapsEnabled = n.experimentalStagedSwaps !== !1, this.neverRetireCoverageEarly = r, this.appendCap = Qe(n.maxSplatsPerSwap);
+    const l = n.initialReveal === "hold-coverage" && this.scene.source.coverageRunsFor !== void 0, c = n.initialReveal === "hold-near-l0" && r;
     l || c ? (this.initialRevealHold = l ? "hold-coverage" : "hold-near-l0", this.initialRevealPhase = "capture", this.initialRevealStateValue = {
       status: "pending",
       stagedSplats: 0,
       totalSplats: 0,
       readyGroups: 0,
       totalGroups: 0
-    }) : (this.initialRevealHold = "off", this.initialRevealPhase = "off", this.initialRevealStateValue = { status: "disabled" }), this.onPerformanceEvent = n.onPerformanceEvent, this.cpuCacheBytes = n.cpuCacheBytes ?? Je(), this.requestOptions = n.request, this.envFile = (u = e.environment) == null ? void 0 : u.file, this.envEnabled = n.environmentEnabled !== !1, this.fetchWeight = n.fetchWeight, this.fetchScheduler = n.fetchScheduler, this.cacheBudget = n.cacheBudget, this.fetchHandle = (g = this.fetchScheduler) == null ? void 0 : g.register({
+    }) : (this.initialRevealHold = "off", this.initialRevealPhase = "off", this.initialRevealStateValue = { status: "disabled" }), this.onPerformanceEvent = n.onPerformanceEvent, this.cpuCacheBytes = n.cpuCacheBytes ?? Je(), this.requestOptions = n.request, this.envFile = (d = e.environment) == null ? void 0 : d.file, this.envEnabled = n.environmentEnabled !== !1, this.fetchWeight = n.fetchWeight, this.fetchScheduler = n.fetchScheduler, this.cacheBudget = n.cacheBudget, this.fetchHandle = (g = this.fetchScheduler) == null ? void 0 : g.register({
       // No weight supplied: claim an equal share rather than none, so a partly
       // wired host degrades to round-robin instead of silently starving.
       weight: () => {
@@ -749,12 +758,12 @@ class Y extends Pe {
       ceilingBytes: f,
       onAllowanceChanged: (m) => this.applyCacheAllowance(m)
     }), this.cacheLimitBytes = this.cacheBudget && this.cacheBudgetHandle ? this.cacheBudget.allowanceFor(this.cacheBudgetHandle) : f, h || (this.cpuCacheBytes = this.cacheLimitBytes), this.fetchCountsValue.cacheLimitBytes = this.cacheLimitBytes, j(n.foveationMode)) {
-      if (!r)
+      if (!a)
         throw new Error("StreamedSplatMesh: page-table foveation requires the frontier worker.");
-      this.pageTableDrawTarget = n.foveationDrawBudget ?? vt, this.pageTableDrawTargetExplicit = n.foveationDrawBudget !== void 0, this.pageTableDrawBudget = Math.min(t, this.pageTableDrawTarget), this.pageTableTargetPx = n.foveationTargetPx ?? se, this.pageTableFoveation = { ...fe, ...n.frontierFoveation }, (n.minSplatScreenRadius !== void 0 || n.maxSplatScreenRadius !== void 0) && (this.frontierBandBase = {
+      this.pageTableDrawTarget = n.foveationDrawBudget ?? vt, this.pageTableDrawTargetExplicit = n.foveationDrawBudget !== void 0, this.pageTableDrawBudget = Math.min(t, this.pageTableDrawTarget), this.pageTableTargetPx = n.foveationTargetPx ?? ie, this.pageTableFoveation = { ...fe, ...n.frontierFoveation }, (n.minSplatScreenRadius !== void 0 || n.maxSplatScreenRadius !== void 0) && (this.frontierBandBase = {
         min: n.minSplatScreenRadius ?? 0,
         max: n.maxSplatScreenRadius ?? 0
-      }), this.slabPageSplats = Math.min(ge, s), this.slabCeiling = s, this.syncSlabPages(this.pageTableDrawBudget), this.frontierWorker = new r(), this.frontierWorker.onmessage = (b) => this.applyFrontierPlan(b.data), this.pagerSlots = this.slabSlots, this.postToWorker({
+      }), this.slabPageSplats = Math.min(ge, i), this.slabCeiling = i, this.syncSlabPages(this.pageTableDrawBudget), this.frontierWorker = new a(), this.frontierWorker.onmessage = (b) => this.applyFrontierPlan(b.data), this.pagerSlots = this.slabSlots, this.postToWorker({
         type: "init",
         capacity: this.pagerSlots,
         chunkSize: e.chunkSize ?? 65536,
@@ -781,10 +790,10 @@ class Y extends Pe {
    * failure, or a `DOMException` named `AbortError` when `options.signal` fires.
    */
   static async load(e, t = {}) {
-    const s = Ae(e, t.baseUrl).href, n = s.toLowerCase(), r = t.format !== void 0 && t.format !== "auto" ? t.format : n.endsWith(".lcc2") ? "lcc2" : n.endsWith(".lcc") ? "lcc" : n.endsWith(".rad") ? "rad" : "streamed-sog";
+    const i = Ae(e, t.baseUrl).href, n = i.toLowerCase(), a = t.format !== void 0 && t.format !== "auto" ? t.format : n.endsWith(".lcc2") ? "lcc2" : n.endsWith(".lcc") ? "lcc" : n.endsWith(".rad") ? "rad" : "streamed-sog";
     return Y.fromSource(
-      nt(s, t.request),
-      r,
+      nt(i, t.request),
+      a,
       t
     );
   }
@@ -803,9 +812,9 @@ class Y extends Pe {
    * `DOMException` named `AbortError` when `options.signal` fires.
    */
   static async loadLocal(e, t = {}) {
-    let s;
+    let i;
     try {
-      s = ot(e);
+      i = ot(e);
     } catch (n) {
       throw n instanceof q ? n : new q(n instanceof Error ? n.message : String(n), {
         phase: "manifest",
@@ -815,42 +824,42 @@ class Y extends Pe {
       });
     }
     try {
-      const n = await Y.fromSource(s.source, s.format, t);
-      return n.localSource = s.source, n;
+      const n = await Y.fromSource(i.source, i.format, t);
+      return n.localSource = i.source, n;
     } catch (n) {
-      throw s.source.dispose(), n;
+      throw i.source.dispose(), n;
     }
   }
   /** Shared load path: fetch the manifest from a source, then build the scene. */
-  static async fromSource(e, t, s) {
-    const n = s.deviceProfile, r = W(s.budget, n, {
+  static async fromSource(e, t, i) {
+    const n = i.deviceProfile, a = W(i.budget, n, {
       format: t,
-      ...s.budgetCap === void 0 ? {} : { cap: s.budgetCap }
-    }), a = s.maxBudget === void 0 ? r : W(s.maxBudget, n);
-    if (a < r)
+      ...i.budgetCap === void 0 ? {} : { cap: i.budgetCap }
+    }), r = i.maxBudget === void 0 ? a : W(i.maxBudget, n);
+    if (r < a)
       throw new RangeError(
-        `StreamedSplatMesh: maxBudget (${a}) must be >= budget (${r}).`
+        `StreamedSplatMesh: maxBudget (${r}) must be >= budget (${a}).`
       );
     const l = {
-      budget: a,
-      lodBaseDistance: s.lodBaseDistance ?? 10,
-      lodMultiplier: s.lodMultiplier ?? 2
-    }, c = s.shBands ?? (Ne(s.performanceProfile, n) === "smooth" ? 0 : De), h = Ee(n), f = s.budget === void 0 && s.maxBudget === void 0 && s.budgetCap === void 0, u = s.signal;
-    u == null || u.throwIfAborted();
+      budget: r,
+      lodBaseDistance: i.lodBaseDistance ?? 10,
+      lodMultiplier: i.lodMultiplier ?? 2
+    }, c = i.shBands ?? (De(i.performanceProfile, n) === "smooth" ? 0 : Ge), h = Pe(n), f = (i.allowFinestLevelLift === !0 || i.budget === void 0 && i.maxBudget === void 0) && i.budgetCap === void 0, d = i.signal;
+    d == null || d.throwIfAborted();
     let g;
     if (t === "rad")
       try {
         const { buildRadScene: p } = await import("./formats/rad.js");
-        g = await p(e, l, s.request, c, f);
+        g = await p(e, l, i.request, c, f);
       } catch (p) {
-        throw G(p) ? p : _(p, { phase: "manifest", url: e.manifestUrl });
+        throw N(p) ? p : _(p, { phase: "manifest", url: e.manifestUrl });
       }
     else {
       let p;
       try {
-        p = await fetch(e.manifestUrl, ee(s.request, u));
+        p = await fetch(e.manifestUrl, ee(i.request, d));
       } catch (S) {
-        throw G(S) ? S : _(S, { phase: "fetch", url: e.manifestUrl });
+        throw N(S) ? S : _(S, { phase: "fetch", url: e.manifestUrl });
       }
       if (!p.ok)
         throw _(
@@ -861,29 +870,29 @@ class Y extends Pe {
         const S = await p.json();
         if (t === "lcc2") {
           const { buildLcc2Scene: M } = await import("./formats/lcc.js");
-          g = M(S, e, l, s.shBands ?? 0);
+          g = M(S, e, l, i.shBands ?? 0);
         } else if (t === "lcc") {
           const { buildLccScene: M } = await import("./formats/lcc.js");
           g = await M(S, e, { ...l, shBands: c });
         } else
-          g = tt(S, e, l, s.shBands ?? 0);
+          g = tt(S, e, l, i.shBands ?? 0);
       } catch (S) {
-        throw G(S) ? S : _(S, { phase: "manifest", url: e.manifestUrl });
+        throw N(S) ? S : _(S, { phase: "manifest", url: e.manifestUrl });
       }
     }
-    u == null || u.throwIfAborted();
-    const v = (t === "lcc" || t === "rad") && f ? ke(a, g.maxResidentSplats, n) : a, m = s.maxBudget === void 0 ? v : Math.min(r, v);
+    d == null || d.throwIfAborted();
+    const v = (t === "lcc" || t === "rad") && f ? ke(r, g.maxResidentSplats, n) : r, m = i.maxBudget === void 0 ? v : Math.min(a, v);
     g.source.budget = m;
-    const b = Math.min(v, g.maxResidentSplats), T = s.experimentalStagedSwaps !== !1 ? 1.5 : 1.4, I = Math.max(
+    const b = Math.min(v, g.maxResidentSplats), T = i.experimentalStagedSwaps !== !1 ? 1.5 : 1.4, I = Math.max(
       1,
       Math.ceil(b * T / F)
     ), y = g.foveation ? ne(
-      s.foveationMode,
+      i.foveationMode,
       t === "rad" ? "page-table" : "frontier"
-    ) : s.foveationMode === void 0 ? void 0 : ne(s.foveationMode);
+    ) : i.foveationMode === void 0 ? void 0 : ne(i.foveationMode);
     let A;
     if (j(y)) {
-      A = (await import("./frontier-worker-CAnK_Cmu.js")).default, u == null || u.throwIfAborted();
+      A = (await import("./frontier-worker-CAnK_Cmu.js")).default, d == null || d.throwIfAborted();
       const S = g.source;
       S.needsParentSizes !== void 0 && (S.needsParentSizes = !1);
     }
@@ -892,13 +901,13 @@ class Y extends Pe {
       m,
       I * F,
       {
-        ...s,
+        ...i,
         // Classic LCC's useful first frame is the bounded nearby-detail set,
         // not its coarse shell. `.lcc2` waits for in-view coarsest coverage
         // so empty octree squares do not flash. Keep every other format
         // progressive, and let a caller explicitly request progressive for A/B.
-        ...t === "lcc" && s.initialReveal === void 0 ? { initialReveal: "hold-near-l0" } : {},
-        ...t === "lcc2" && s.initialReveal === void 0 ? { initialReveal: "hold-coverage" } : {},
+        ...t === "lcc" && i.initialReveal === void 0 ? { initialReveal: "hold-near-l0" } : {},
+        ...t === "lcc2" && i.initialReveal === void 0 ? { initialReveal: "hold-coverage" } : {},
         // The resolved ceiling, not the caller's raw option: it may have been
         // lifted to a moderate capture's leaf count above.
         maxBudget: v,
@@ -914,7 +923,7 @@ class Y extends Pe {
         // compensation `α·√(detRaw/detBlur)`). Match that default for `.rad`: the
         // 0.3 low-pass without the compensation makes splats too opaque (uniform
         // blur) and leaves anisotropic splats bright (needle spikes).
-        antialias: s.antialias ?? (t === "rad" ? !0 : void 0),
+        antialias: i.antialias ?? (t === "rad" ? !0 : void 0),
         // Older XGRIDS LCC uses a smaller, compensated projected low-pass.
         ...t === "lcc" ? { projectedFilterProfile: "lcc" } : {},
         // Match Spark's `.rad` render exactly: the LOD alpha encoding + merged-node
@@ -926,8 +935,8 @@ class Y extends Pe {
         // same 4 ceiling `.rad` was the only format escaping. An explicit
         // `maxStdDev` still wins, through `...options` above.
         ...t === "rad" ? {
-          lodAlpha: s.lodAlpha ?? !0,
-          ...s.maxStdDev === void 0 && h !== void 0 ? { maxStdDev: h } : {}
+          lodAlpha: i.lodAlpha ?? !0,
+          ...i.maxStdDev === void 0 && h !== void 0 ? { maxStdDev: h } : {}
         } : {},
         // A foveated scene renders whole chunks and picks the LOD cut per splat.
         // `.rad` defaults to Spark's selected-index page table (only the frontier is
@@ -943,7 +952,7 @@ class Y extends Pe {
       A,
       t === "lcc"
     ), L = g.formatTransform ?? (R.orientation === "y-up" ? xe(t) : null);
-    return L && (R.matrix.copy(L), R.matrix.decompose(R.position, R.quaternion, R.scale), R.matrixWorldNeedsUpdate = !0), u != null && u.aborted && (R.dispose(), u.throwIfAborted()), R;
+    return L && (R.matrix.copy(L), R.matrix.decompose(R.position, R.quaternion, R.scale), R.matrixWorldNeedsUpdate = !0), d != null && d.aborted && (R.dispose(), d.throwIfAborted()), R;
   }
   /** Slots the currently reserved pages can hold. */
   get slabSlots() {
@@ -965,47 +974,47 @@ class Y extends Pe {
   syncSlabPages(e) {
     if (this.slabCeiling === 0) return;
     const t = Math.max(this.slabPageSplats, Math.min(this.slabCeiling, e));
-    let s = this.slabSlots;
-    for (; s < t; ) {
-      const n = Math.min(this.slabPageSplats, this.slabCeiling - s);
+    let i = this.slabSlots;
+    for (; i < t; ) {
+      const n = Math.min(this.slabPageSplats, this.slabCeiling - i);
       if (n <= 0) break;
       try {
         this.slabPages.push(this.reserveInactiveRange(n));
       } catch {
         break;
       }
-      s += n;
+      i += n;
     }
     for (; this.slabPages.length > 1; ) {
       const n = this.slabPages[this.slabPages.length - 1];
-      if (s - n.count < t) break;
-      this.slabPages.pop(), s -= n.count, this.removeRange(n);
+      if (i - n.count < t) break;
+      this.slabPages.pop(), i -= n.count, this.removeRange(n);
     }
-    s !== this.pagerSlots && (this.pagerSlots = s, this.postToWorker({ type: "resize", capacity: s }), this.pageTableDrawn > s && this.setSlabResident(s), this.pendingWork = !0, this.lastScheduleTime = -1 / 0);
+    i !== this.pagerSlots && (this.pagerSlots = i, this.postToWorker({ type: "resize", capacity: i }), this.pageTableDrawn > i && this.setSlabResident(i), this.pendingWork = !0, this.lastScheduleTime = -1 / 0);
   }
   /**
    * Writes `data` at slot `slot`, splitting the write where it crosses a page
    * boundary. The pager's runs are contiguous in *slot* space, which page
    * storage no longer guarantees is contiguous in the pool.
    */
-  writeSlabSlots(e, t, s) {
+  writeSlabSlots(e, t, i) {
     let n = 0;
-    for (; n < s; ) {
-      const r = t + n, a = this.slabPages[Math.floor(r / this.slabPageSplats)];
-      if (!a) return;
-      const l = r % this.slabPageSplats, c = Math.min(s - n, this.slabPageSplats - l);
-      this.overwriteRangeData(a, K(e, n, c), l), n += c;
+    for (; n < i; ) {
+      const a = t + n, r = this.slabPages[Math.floor(a / this.slabPageSplats)];
+      if (!r) return;
+      const l = a % this.slabPageSplats, c = Math.min(i - n, this.slabPageSplats - l);
+      this.overwriteRangeData(r, K(e, n, c), l), n += c;
     }
   }
   /** Zeros slots `[slot, slot + count)`, splitting at page boundaries like
    * {@link writeSlabSlots}, so freed slots hold nothing drawable. */
   degenerateSlabSlots(e, t) {
-    let s = 0;
-    for (; s < t; ) {
-      const n = e + s, r = this.slabPages[Math.floor(n / this.slabPageSplats)];
-      if (!r) return;
-      const a = n % this.slabPageSplats, l = Math.min(t - s, this.slabPageSplats - a);
-      this.degenerateRange(r, a, l), s += l;
+    let i = 0;
+    for (; i < t; ) {
+      const n = e + i, a = this.slabPages[Math.floor(n / this.slabPageSplats)];
+      if (!a) return;
+      const r = n % this.slabPageSplats, l = Math.min(t - i, this.slabPageSplats - r);
+      this.degenerateRange(a, r, l), i += l;
     }
   }
   /**
@@ -1017,17 +1026,17 @@ class Y extends Pe {
    */
   setSlabResident(e) {
     for (let t = 0; t < this.slabPages.length; t++) {
-      const s = Math.min(
+      const i = Math.min(
         this.slabPageSplats,
         Math.max(0, e - t * this.slabPageSplats)
       );
-      this.setRangeActivePrefix(this.slabPages[t], s);
+      this.setRangeActivePrefix(this.slabPages[t], i);
     }
   }
   /** Typed post to the frontier worker. */
   postToWorker(e, t = []) {
-    var s;
-    (s = this.frontierWorker) == null || s.postMessage(e, t);
+    var i;
+    (i = this.frontierWorker) == null || i.postMessage(e, t);
   }
   /**
    * Applies a new decoded-chunk allowance from the scene's shared
@@ -1073,33 +1082,33 @@ class Y extends Pe {
    * {@link dispose} is called while the load is in flight.
    */
   async loadCollisionMeshes(e = {}) {
-    var r;
-    (r = e.signal) == null || r.throwIfAborted();
+    var a;
+    (a = e.signal) == null || a.throwIfAborted();
     const t = this.scene.collision;
     if (!t || t.meshes.length === 0) return [];
     if (!this.collisionTiles) {
-      const a = new AbortController();
-      this.collisionAbort = a, this.collisionTiles = import("./formats/lcc.js").then(
+      const r = new AbortController();
+      this.collisionAbort = r, this.collisionTiles = import("./formats/lcc.js").then(
         ({ loadCollisionMeshTiles: l }) => l(t, {
           ...this.requestOptions ? { request: this.requestOptions } : {},
-          signal: a.signal
+          signal: r.signal
         })
       ).catch((l) => {
         throw this.collisionTiles = void 0, l;
       });
     }
-    const { signal: s } = e;
-    if (!s) return this.collisionTiles;
+    const { signal: i } = e;
+    if (!i) return this.collisionTiles;
     let n;
     try {
       return await Promise.race([
         this.collisionTiles,
-        new Promise((a, l) => {
-          n = () => l(Ke(s)), s.addEventListener("abort", n, { once: !0 });
+        new Promise((r, l) => {
+          n = () => l(Ke(i)), i.addEventListener("abort", n, { once: !0 });
         })
       ]);
     } finally {
-      n && s.removeEventListener("abort", n);
+      n && i.removeEventListener("abort", n);
     }
   }
   /**
@@ -1168,6 +1177,14 @@ class Y extends Pe {
   get contentSplatCount() {
     return this.scene.contentSplatCount;
   }
+  /**
+   * Which `.rad` streaming strategy this mesh selected at load, or `null` when
+   * the scene is not a Spark `.rad` capture.
+   */
+  get radStrategy() {
+    var e, t;
+    return ((t = (e = this.scene.chunkOptions) == null ? void 0 : e[0]) == null ? void 0 : t.format) !== "rad-chunk" ? null : this.frontierWorker ? "page-table" : "prefix";
+  }
   /**
    * The drawn-splat target currently driving the `.rad` page-table frontier -
    * the governed budget, capped by
@@ -1181,6 +1198,23 @@ class Y extends Pe {
   get drawBudget() {
     return this.frontierWorker ? this.pageTableDrawBudget : 0;
   }
+  /**
+   * Page-table frontier coherence for hosts that gate preload/transitions.
+   * `undefined` fields stay 0 when this mesh is not in page-table mode.
+   */
+  get frontierState() {
+    return {
+      frontierConverged: this.frontierWorker ? this.frontierConverged : !0,
+      pendingFrontierSplats: this.pendingFrontierSplats,
+      staleResidentSplats: this.staleResidentSplats,
+      lastPlanAppends: this.lastPlanAppends,
+      lastPlanMoves: this.lastPlanMoves,
+      planGeneration: this.lastPlanGeneration,
+      planBudget: this.lastPlanBudget,
+      lastPlanCamera: this.lastPlanCamera,
+      firstFrontierCamera: this.firstFrontierCamera
+    };
+  }
   /**
    * Spark's per-mesh `lodScale` (see {@link StreamedSplatMeshOptions.lodScale}).
    * Mutable: raise it to sharpen a focused mesh, lower it to coarsen a
@@ -1211,7 +1245,7 @@ class Y extends Pe {
    */
   setBudget(e) {
     const t = Math.min(W(e), this.maximumBudget);
-    return t === this.budgetValue ? this.budgetValue : (this.budgetValue = t, this.scene.source.budget = t, this.frontierWorker && (this.pageTableDrawBudget = Math.min(t, this.pageTableDrawTarget), this.syncSlabPages(this.pageTableDrawBudget), this.pageTableDrawTargetExplicit && this.pageTableDrawTarget < t && !this.warnedDrawTargetCap && (this.warnedDrawTargetCap = !0, P(
+    return t === this.budgetValue ? this.budgetValue : (this.budgetValue = t, this.scene.source.budget = t, this.frontierWorker && (this.pageTableDrawBudget = Math.min(t, this.pageTableDrawTarget), this.syncSlabPages(this.pageTableDrawBudget), this.pageTableDrawTargetExplicit && this.pageTableDrawTarget < t && !this.warnedDrawTargetCap && (this.warnedDrawTargetCap = !0, E(
       `StreamedSplatMesh: budget raised to ${t} but foveationDrawBudget caps the drawn frontier at ${this.pageTableDrawTarget}; the extra budget cannot buy detail. Raise or drop foveationDrawBudget to let the shared budget through.`
     ))), this.pendingWork = !0, this.lastScheduleTime = -1 / 0, t);
   }
@@ -1310,13 +1344,13 @@ class Y extends Pe {
   set lodBaseDistance(e) {
     this.scene.source.lodBaseDistance = e, this.pendingWork = !0;
   }
-  update(e, t, s = {}) {
+  update(e, t, i = {}) {
     const n = performance.now();
     e.updateMatrixWorld(), this.updateWorldMatrix(!0, !1);
-    const r = Le(e, t);
-    this.frontierWorker && (r ? this.pageTableViewportY = r.height : (t.getDrawingBufferSize(Se), this.pageTableViewportY = Se.y));
-    const a = (r == null ? void 0 : r.head) ?? e, l = this.shouldReschedule(a, n) ? this.reschedule(a, n) : null;
-    if (super.update(e, t, s), l && this.onPerformanceEvent) {
+    const a = Le(e, t);
+    this.frontierWorker && (a ? this.pageTableViewportY = a.height : (t.getDrawingBufferSize(Se), this.pageTableViewportY = Se.y));
+    const r = (a == null ? void 0 : a.head) ?? e, l = this.shouldReschedule(r, n) ? this.reschedule(r, n) : null;
+    if (super.update(e, t, i), l && this.onPerformanceEvent) {
       const c = this.getUpdateTimings();
       l.cpuMs += performance.now() - l.timestamp, l.activeListMs = c.activeListMs, l.uploadMs = c.uploadMs, l.sortSubmitMs = c.sortSubmitMs, l.stagingTextureAllocations = c.stagingTextureAllocations, l.activeListUpdateRanges = c.activeListUpdateRanges, this.onPerformanceEvent(l);
     }
@@ -1334,10 +1368,10 @@ class Y extends Pe {
   setLodLevelDebug(e) {
     if (e) {
       this.lodLevelChannelReady || (this.defineChannel("lodLevel", { type: "float", fill: -1 }), this.lodLevelChannelReady = !0), this.lodLevelDebug = !0;
-      for (const { run: t, handle: s } of this.resident.values())
-        this.writeLodLevelChannel(s, t.level);
-      for (const { run: t, handle: s, uploadedCount: n } of this.staged.values())
-        n === t.count && this.writeLodLevelChannel(s, t.level);
+      for (const { run: t, handle: i } of this.resident.values())
+        this.writeLodLevelChannel(i, t.level);
+      for (const { run: t, handle: i, uploadedCount: n } of this.staged.values())
+        n === t.count && this.writeLodLevelChannel(i, t.level);
       return;
     }
     this.lodLevelDebug = !1;
@@ -1411,38 +1445,38 @@ class Y extends Pe {
    * @throws {Error} if the channel was not declared with
    *   {@link definePersistentChannel}.
    */
-  paintPersistent(e, t, s, n) {
-    const r = this.persistentChannels.get(e);
-    if (!r)
+  paintPersistent(e, t, i, n) {
+    const a = this.persistentChannels.get(e);
+    if (!a)
       throw new Error(
         `StreamedSplatMesh.paintPersistent: channel "${e}" is not a persistent channel. Call definePersistentChannel("${e}") first.`
       );
     V.copy(t), this.worldToLocal(V);
-    const a = s * s;
+    const r = i * i;
     let l = 0;
     const c = /* @__PURE__ */ new Set();
     for (const { run: h } of this.resident.values()) {
       const f = this.cache.get(h.file);
       if (!f) continue;
-      const u = f.data.positions, g = r.edits.get(h.file) ?? /* @__PURE__ */ new Map();
+      const d = f.data.positions, g = a.edits.get(h.file) ?? /* @__PURE__ */ new Map();
       let v = !1;
       for (let m = 0; m < h.count; m++) {
-        const b = h.offset + m, T = u[b * 3 + 0] - V.x, I = u[b * 3 + 1] - V.y, y = u[b * 3 + 2] - V.z;
-        if (!(T * T + I * I + y * y > a) && !g.has(b)) {
-          if (r.total >= r.maxEdits) {
-            r.warned || (r.warned = !0, P(
-              `StreamedSplatMesh.paintPersistent: channel "${e}" hit its maxEdits cap (${r.maxEdits}); further new edits are dropped.`
+        const b = h.offset + m, T = d[b * 3 + 0] - V.x, I = d[b * 3 + 1] - V.y, y = d[b * 3 + 2] - V.z;
+        if (!(T * T + I * I + y * y > r) && !g.has(b)) {
+          if (a.total >= a.maxEdits) {
+            a.warned || (a.warned = !0, E(
+              `StreamedSplatMesh.paintPersistent: channel "${e}" hit its maxEdits cap (${a.maxEdits}); further new edits are dropped.`
             ));
             continue;
           }
-          r.total++, g.set(b, n), v = !0, l++;
+          a.total++, g.set(b, n), v = !0, l++;
         }
       }
-      v && (r.edits.set(h.file, g), c.add(h.file));
+      v && (a.edits.set(h.file, g), c.add(h.file));
     }
     if (c.size > 0)
       for (const { run: h, handle: f } of this.resident.values())
-        c.has(h.file) && this.applyPersistentRun(e, r, h, f);
+        c.has(h.file) && this.applyPersistentRun(e, a, h, f);
     return l;
   }
   /**
@@ -1459,48 +1493,48 @@ class Y extends Pe {
         `StreamedSplatMesh.clearPersistentChannel: channel "${e}" is not a persistent channel.`
       );
     t.edits.clear(), t.total = 0;
-    for (const { run: s, handle: n } of this.resident.values()) {
-      const r = t.type === "byte" ? new Uint8Array(s.count) : new Float32Array(s.count);
-      this.writeChannel(n, e, r);
+    for (const { run: i, handle: n } of this.resident.values()) {
+      const a = t.type === "byte" ? new Uint8Array(i.count) : new Float32Array(i.count);
+      this.writeChannel(n, e, a);
     }
   }
   dispose() {
-    var e, t, s, n, r;
+    var e, t, i, n, a;
     if (!this.disposed) {
       this.loader.dispose(), this.frontierWorker && (this.frontierWorker.onmessage = null, this.frontierWorker.terminate()), this.pageTableDisposed = !0, (e = this.collisionAbort) == null || e.abort(), (t = this.collisionTiles) == null || t.catch(() => {
       }), this.collisionTiles = void 0;
-      for (const { controller: a } of this.fetching.values()) a.abort();
-      if (this.fetching.clear(), this.fetchHandle && ((s = this.fetchScheduler) == null || s.unregister(this.fetchHandle)), this.cacheBudgetHandle) {
-        const a = this.cacheBudgetHandle;
-        this.cacheBudgetHandle = void 0, (n = this.cacheBudget) == null || n.unregister(a);
+      for (const { controller: r } of this.fetching.values()) r.abort();
+      if (this.fetching.clear(), this.fetchHandle && ((i = this.fetchScheduler) == null || i.unregister(this.fetchHandle)), this.cacheBudgetHandle) {
+        const r = this.cacheBudgetHandle;
+        this.cacheBudgetHandle = void 0, (n = this.cacheBudget) == null || n.unregister(r);
       }
-      (r = this.localSource) == null || r.dispose(), this.localSource = void 0, this.cache.clear(), this.cacheBytesTotal = 0, this.retrying.clear(), this.failedFiles.clear(), this.neededFiles.clear(), this.persistentChannels.clear(), this.resident.clear(), this.staged.clear(), this.pageTableCachedFiles.clear(), this.envHandle = void 0, this.envSplatCount = 0, super.dispose();
+      (a = this.localSource) == null || a.dispose(), this.localSource = void 0, this.cache.clear(), this.cacheBytesTotal = 0, this.retrying.clear(), this.failedFiles.clear(), this.neededFiles.clear(), this.persistentChannels.clear(), this.resident.clear(), this.staged.clear(), this.pageTableCachedFiles.clear(), this.envHandle = void 0, this.envSplatCount = 0, super.dispose();
     }
   }
   shouldReschedule(e, t) {
     if (this.pendingWork || t - this.lastScheduleTime > ft) return !0;
     e.getWorldPosition(pe);
-    const s = this.scene.bounds.getBoundingSphere(wt).radius || 1;
-    return pe.distanceTo(this.lastCameraPos) > s * 25e-4 ? !0 : (e.getWorldQuaternion(me), me.angleTo(this.lastCameraQuat) > 87e-4);
+    const i = this.scene.bounds.getBoundingSphere(wt).radius || 1;
+    return pe.distanceTo(this.lastCameraPos) > i * 25e-4 ? !0 : (e.getWorldQuaternion(me), me.angleTo(this.lastCameraQuat) > 87e-4);
   }
   reschedule(e, t) {
     var L;
-    const s = performance.now();
+    const i = performance.now();
     let n = null;
     if (this.onPerformanceEvent !== void 0) {
       n = { resident: /* @__PURE__ */ new Map(), staged: /* @__PURE__ */ new Map() };
       for (const [p, S] of this.resident) n.resident.set(p, S.run.count);
       for (const [p, S] of this.staged) n.staged.set(p, S.uploadedCount);
     }
-    const r = this.compactionCount;
-    if (this.pendingWork = !1, this.lastScheduleTime = t, e.getWorldPosition(this.lastCameraPos), e.getWorldQuaternion(this.lastCameraQuat), x.copy(this.lastCameraPos), this.worldToLocal(x), ve.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse).multiply(this.matrixWorld), z.setFromProjectionMatrix(ve), this.frontierWorker) {
+    const a = this.compactionCount;
+    if (this.pendingWork = !1, this.lastScheduleTime = t, e.getWorldPosition(this.lastCameraPos), e.getWorldQuaternion(this.lastCameraQuat), x.copy(this.lastCameraPos), this.worldToLocal(x), ve.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse).multiply(this.matrixWorld), O.setFromProjectionMatrix(ve), this.frontierWorker) {
       e.getWorldDirection(B).add(this.lastCameraPos), this.worldToLocal(B), B.sub(x).normalize();
       const p = e.projectionMatrix.elements[5] * this.pageTableViewportY / 2;
-      if (p > 0 && (this.pageTableLimit = this.pageTableTargetPx / p), this.reschedulePageTable(x, B, z, t), this.onPerformanceEvent === void 0) return null;
+      if (p > 0 && (this.pageTableLimit = this.pageTableTargetPx / p), this.reschedulePageTable(x, B, O, t), this.onPerformanceEvent === void 0) return null;
       const S = performance.now();
       return {
         timestamp: S,
-        cpuMs: S - s,
+        cpuMs: S - i,
         activeListMs: 0,
         uploadMs: 0,
         sortSubmitMs: 0,
@@ -1516,25 +1550,25 @@ class Y extends Pe {
       };
     }
     e.getWorldDirection(B).add(this.lastCameraPos), this.worldToLocal(B), B.sub(x).normalize();
-    const a = this.scene.source.computeDesiredRuns(
+    const r = this.scene.source.computeDesiredRuns(
       x,
-      z,
+      O,
       t,
       B
     ), l = this.captureOrContinueInitialReveal(
-      a,
+      r,
       t,
       x,
-      z
-    ), c = l !== null, h = l ?? a, f = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Set();
+      O
+    ), c = l !== null, h = l ?? r, f = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Set();
     for (const p of h)
-      f.set(C(p), p), u.add(p.file);
+      f.set(C(p), p), d.add(p.file);
     for (const [p, S] of this.staged)
       f.has(p) || c && ((L = this.frozenCriticalRuns) != null && L.some((M) => C(M) === p)) || (this.removeRange(S.handle), this.staged.delete(p));
     for (const [p, { controller: S }] of this.fetching)
-      !u.has(p) && !this.scene.pinnedFiles.has(p) && S.abort();
+      !d.has(p) && !this.scene.pinnedFiles.has(p) && S.abort();
     for (const p of this.retrying.keys())
-      !u.has(p) && !this.scene.pinnedFiles.has(p) && this.retrying.delete(p);
+      !d.has(p) && !this.scene.pinnedFiles.has(p) && this.retrying.delete(p);
     this.neededFiles.clear();
     for (const p of h) {
       const S = C(p);
@@ -1548,16 +1582,16 @@ class Y extends Pe {
       // irrelevant - commit each frozen slice as it lands so a partial home
       // cell cannot block reveal behind sibling subchunks still fetching.
       _e(g)
-    ) : ze(g, v), b = !c && Oe(m);
+    ) : Oe(g, v), b = !c && ze(m);
     m.sort(
-      (p, S) => b ? Ue(p, S) : re(p) - re(S)
+      (p, S) => b ? Ue(p, S) : ae(p) - ae(S)
     );
     const T = /* @__PURE__ */ new Map();
     this.updateEnvironment(t, T);
     let I = 0, y = !1, A = !1, R = !1;
     for (const p of m) {
       if (!b && p.removes.length > 0 && y) {
-        if (this.neverRetireCoverageEarly || !A && this.retireHeldTicks < dt) {
+        if (this.neverRetireCoverageEarly || !A && this.retireHeldTicks < ut) {
           this.pendingWork = !0, R = !0;
           continue;
         }
@@ -1567,32 +1601,32 @@ class Y extends Pe {
         this.applyGroup(p, t);
         continue;
       }
-      const S = p.adds.filter((E) => !this.cache.has(E.file)), M = c || Ye(p) && this.initialRevealHold !== "hold-coverage";
+      const S = p.adds.filter((P) => !this.cache.has(P.file)), M = c || Ye(p) && this.initialRevealHold !== "hold-coverage";
       if (S.length > 0) {
-        let E = !1;
+        let P = !1;
         for (const k of S)
           this.failedFiles.has(k.file) || (oe(
             T,
             k.file,
             qe(k, this.scene.source.lodBaseDistance),
             k
-          ), E = !0);
-        if (c || this.substituteCoverage(p, t, T, M), E && (this.pendingWork = !0, y = !0), !c) continue;
+          ), P = !0);
+        if (c || this.substituteCoverage(p, t, T, M), P && (this.pendingWork = !0, y = !0), !c) continue;
       }
       if (c && this.environmentPendingForReveal()) {
         this.pendingWork = !0, y = !0;
         continue;
       }
       if ((c || this.stagedSwapsEnabled && p.addCount > this.appendCap) && this.canStageGroup(p)) {
-        const E = this.stageGroup(p, t, Math.max(0, this.appendCap - I));
-        if (I += E, !p.adds.every((k) => {
-          var ie;
-          return ((ie = this.staged.get(C(k))) == null ? void 0 : ie.uploadedCount) === k.count;
+        const P = this.stageGroup(p, t, Math.max(0, this.appendCap - I));
+        if (I += P, !p.adds.every((k) => {
+          var se;
+          return ((se = this.staged.get(C(k))) == null ? void 0 : se.uploadedCount) === k.count;
         })) {
           this.pendingWork = !0, y = !0;
           continue;
         }
-        if (E > 0 && !c) {
+        if (P > 0 && !c) {
           this.deferNextSortRequest(), this.pendingWork = !0, y = !0;
           continue;
         }
@@ -1616,8 +1650,8 @@ class Y extends Pe {
     return this.flushClassicFetches(T, this.scene.source.lodBaseDistance, c), this.retireHeldTicks = R ? this.retireHeldTicks + 1 : 0, c && (this.finishInitialRevealIfComplete(), this.initialRevealPhase === "holding" && (this.pendingWork = !0)), this.fetchCountsValue.cacheBytes = this.cacheBytesTotal, this.fetchCountsValue.cacheLimitBytes = this.cpuCacheBytes, this.cacheBytesTotal > this.cpuCacheBytes && (this.fetchCountsValue.cacheFull = !0), this.evictChunks(t), n === null ? null : this.createPerformanceEvent(
       n.resident,
       n.staged,
-      r,
-      s
+      a,
+      i
     );
   }
   rowAlignedSplats(e) {
@@ -1631,39 +1665,39 @@ class Y extends Pe {
    * Coarser home levels come from {@link LodSource.runsAtLevelFor}.
    */
   selectHomeSeedRuns(e) {
-    var r;
-    const t = this.scene.source.lodBaseDistance, s = e.filter(
-      (a) => a.coverageGroup !== void 0 && (a.distance ?? Number.POSITIVE_INFINITY) <= t
+    var a;
+    const t = this.scene.source.lodBaseDistance, i = e.filter(
+      (r) => r.coverageGroup !== void 0 && (r.distance ?? Number.POSITIVE_INFINITY) <= t
     ).sort(
-      (a, l) => (a.distance ?? Number.POSITIVE_INFINITY) - (l.distance ?? Number.POSITIVE_INFINITY) || // Same distance: prefer in-view, then finer.
-      (a.inView === !0 ? 0 : 1) - (l.inView === !0 ? 0 : 1) || a.level - l.level || a.leafStart - l.leafStart
-    ), n = (r = s[0]) == null ? void 0 : r.coverageGroup;
-    return n === void 0 ? [] : s.filter((a) => a.coverageGroup === n);
+      (r, l) => (r.distance ?? Number.POSITIVE_INFINITY) - (l.distance ?? Number.POSITIVE_INFINITY) || // Same distance: prefer in-view, then finer.
+      (r.inView === !0 ? 0 : 1) - (l.inView === !0 ? 0 : 1) || r.level - l.level || r.leafStart - l.leafStart
+    ), n = (a = i[0]) == null ? void 0 : a.coverageGroup;
+    return n === void 0 ? [] : i.filter((r) => r.coverageGroup === n);
   }
   coarsenHomeRuns(e, t) {
-    var r;
-    const s = [], n = this.scene.source;
-    for (const a of e) {
-      if (a.level === t) {
-        s.push(a);
+    var a;
+    const i = [], n = this.scene.source;
+    for (const r of e) {
+      if (r.level === t) {
+        i.push(r);
         continue;
       }
-      const l = ((r = n.runsAtLevelFor) == null ? void 0 : r.call(n, a.leafStart, a.leafEnd, t)) ?? [];
+      const l = ((a = n.runsAtLevelFor) == null ? void 0 : a.call(n, r.leafStart, r.leafEnd, t)) ?? [];
       if (l.length !== 0)
         for (const c of l)
-          s.push({
+          i.push({
             ...c,
-            distance: a.distance,
-            inView: a.inView,
-            ...a.coverageGroup === void 0 ? {} : { coverageGroup: a.coverageGroup },
-            ...a.screenImportance === void 0 ? {} : { screenImportance: a.screenImportance }
+            distance: r.distance,
+            inView: r.inView,
+            ...r.coverageGroup === void 0 ? {} : { coverageGroup: r.coverageGroup },
+            ...r.screenImportance === void 0 ? {} : { screenImportance: r.screenImportance }
           });
     }
-    return s;
+    return i;
   }
   criticalRunsFitCapacity(e) {
     let t = 0;
-    for (const s of e) t += this.rowAlignedSplats(s.count);
+    for (const i of e) t += this.rowAlignedSplats(i.count);
     return t <= this.freeSplatCapacity;
   }
   publishInitialRevealProgress(e) {
@@ -1673,50 +1707,50 @@ class Y extends Pe {
       let h = t.get(c);
       h || (h = [], t.set(c, h)), h.push(l);
     }
-    let s = 0, n = 0, r = 0;
+    let i = 0, n = 0, a = 0;
     for (const l of t.values()) {
       let c = !0;
       for (const h of l) {
         n += h.count;
         const f = C(h);
         if (this.resident.has(f)) {
-          s += h.count;
+          i += h.count;
           continue;
         }
-        const u = this.staged.get(f);
-        s += (u == null ? void 0 : u.uploadedCount) ?? 0, (!u || u.uploadedCount !== h.count) && (c = !1);
+        const d = this.staged.get(f);
+        i += (d == null ? void 0 : d.uploadedCount) ?? 0, (!d || d.uploadedCount !== h.count) && (c = !1);
       }
-      c && r++;
+      c && a++;
     }
-    const a = this.initialRevealStateValue;
-    if (a.status === "degraded") {
+    const r = this.initialRevealStateValue;
+    if (r.status === "degraded") {
       this.initialRevealStateValue = {
         status: "degraded",
-        reason: a.reason,
-        stagedSplats: s,
+        reason: r.reason,
+        stagedSplats: i,
         totalSplats: n,
-        readyGroups: r,
+        readyGroups: a,
         totalGroups: t.size
       };
       return;
     }
     this.initialRevealStateValue = {
       status: "pending",
-      stagedSplats: s,
+      stagedSplats: i,
       totalSplats: n,
-      readyGroups: r,
+      readyGroups: a,
       totalGroups: t.size
     };
   }
   releaseInitialReveal(e, t) {
-    const s = this.frozenCriticalRuns ?? [];
-    this.publishInitialRevealProgress(s);
-    const n = this.initialRevealStateValue, r = n.status === "pending" || n.status === "degraded" ? n.stagedSplats : 0, a = n.status === "pending" || n.status === "degraded" ? n.totalSplats : 0, l = n.status === "pending" || n.status === "degraded" ? n.readyGroups : 0, c = n.status === "pending" || n.status === "degraded" ? n.totalGroups : 0;
+    const i = this.frozenCriticalRuns ?? [];
+    this.publishInitialRevealProgress(i);
+    const n = this.initialRevealStateValue, a = n.status === "pending" || n.status === "degraded" ? n.stagedSplats : 0, r = n.status === "pending" || n.status === "degraded" ? n.totalSplats : 0, l = n.status === "pending" || n.status === "degraded" ? n.readyGroups : 0, c = n.status === "pending" || n.status === "degraded" ? n.totalGroups : 0;
     e === "ready" ? this.initialRevealStateValue = { status: "ready" } : this.initialRevealStateValue = {
       status: "degraded",
       reason: t ?? "fetch-failed",
-      stagedSplats: r,
-      totalSplats: a,
+      stagedSplats: a,
+      totalSplats: r,
       readyGroups: l,
       totalGroups: c
     }, this.frozenCriticalRuns = null, this.initialRevealPhase = "released", this.pendingWork = !0;
@@ -1726,12 +1760,12 @@ class Y extends Pe {
    * Missing `coverageRunsFor` (or an empty result after fallback) releases
    * immediately so the mesh does not stay hidden with nothing to fetch.
    */
-  captureCoverageHold(e, t, s) {
-    var r, a;
-    const n = ((a = (r = this.scene.source).coverageRunsFor) == null ? void 0 : a.call(r, e, t)) ?? [];
+  captureCoverageHold(e, t, i) {
+    var a, r;
+    const n = ((r = (a = this.scene.source).coverageRunsFor) == null ? void 0 : r.call(a, e, t)) ?? [];
     if (n.length === 0) {
       if (this.environmentPendingForReveal()) {
-        this.frozenCriticalRuns = [], this.initialRevealStartedAt = s, this.initialRevealPhase = "holding", this.publishInitialRevealProgress([]);
+        this.frozenCriticalRuns = [], this.initialRevealStartedAt = i, this.initialRevealPhase = "holding", this.publishInitialRevealProgress([]);
         return;
       }
       this.initialRevealStateValue = { status: "ready" }, this.initialRevealPhase = "released";
@@ -1741,54 +1775,54 @@ class Y extends Pe {
       this.frozenCriticalRuns = n, this.releaseInitialReveal("degraded", "capacity");
       return;
     }
-    this.frozenCriticalRuns = n, this.initialRevealStartedAt = s, this.initialRevealPhase = "holding", this.publishInitialRevealProgress(n);
+    this.frozenCriticalRuns = n, this.initialRevealStartedAt = i, this.initialRevealPhase = "holding", this.publishInitialRevealProgress(n);
   }
-  captureOrContinueInitialReveal(e, t, s, n) {
+  captureOrContinueInitialReveal(e, t, i, n) {
     if (this.initialRevealPhase === "off" || this.initialRevealPhase === "released") return null;
     if (this.initialRevealPhase === "capture")
       if (this.initialRevealHold === "hold-coverage")
-        this.captureCoverageHold(s, n, t);
+        this.captureCoverageHold(i, n, t);
       else {
-        const r = this.selectHomeSeedRuns(e);
-        let a = [];
-        if (r.length === 0) {
+        const a = this.selectHomeSeedRuns(e);
+        let r = [];
+        if (a.length === 0) {
           const l = this.scene.source.lodBaseDistance * this.scene.source.lodMultiplier * this.scene.source.lodMultiplier, c = e.filter(
             (f) => f.level <= 2 && f.coverageGroup !== void 0 && (f.distance ?? Number.POSITIVE_INFINITY) <= l
           ), h = [...c].sort(
-            (f, u) => (f.distance ?? Number.POSITIVE_INFINITY) - (u.distance ?? Number.POSITIVE_INFINITY) || (f.inView === !0 ? 0 : 1) - (u.inView === !0 ? 0 : 1) || (f.screenImportance ?? Number.POSITIVE_INFINITY) - (u.screenImportance ?? Number.POSITIVE_INFINITY) || f.leafStart - u.leafStart
+            (f, d) => (f.distance ?? Number.POSITIVE_INFINITY) - (d.distance ?? Number.POSITIVE_INFINITY) || (f.inView === !0 ? 0 : 1) - (d.inView === !0 ? 0 : 1) || (f.screenImportance ?? Number.POSITIVE_INFINITY) - (d.screenImportance ?? Number.POSITIVE_INFINITY) || f.leafStart - d.leafStart
           )[0];
           if (!h)
             return this.initialRevealStateValue = { status: "ready" }, this.initialRevealPhase = "released", null;
-          if (a = h.coverageGroup !== void 0 ? c.filter((f) => f.coverageGroup === h.coverageGroup) : [h], this.criticalRunsFitCapacity(a) || (a = h.coverageGroup !== void 0 ? c.filter(
+          if (r = h.coverageGroup !== void 0 ? c.filter((f) => f.coverageGroup === h.coverageGroup) : [h], this.criticalRunsFitCapacity(r) || (r = h.coverageGroup !== void 0 ? c.filter(
             (f) => f.coverageGroup === h.coverageGroup && this.criticalRunsFitCapacity([f])
-          ).slice(0, 1) : c.filter((f) => this.criticalRunsFitCapacity([f])).slice(0, 1)), a.length === 0 || !this.criticalRunsFitCapacity(a))
-            return this.frozenCriticalRuns = a.length > 0 ? a : [h], this.releaseInitialReveal("degraded", "capacity"), null;
-          this.frozenCriticalRuns = a, this.initialRevealStartedAt = t, this.initialRevealPhase = "holding", this.publishInitialRevealProgress(a);
+          ).slice(0, 1) : c.filter((f) => this.criticalRunsFitCapacity([f])).slice(0, 1)), r.length === 0 || !this.criticalRunsFitCapacity(r))
+            return this.frozenCriticalRuns = r.length > 0 ? r : [h], this.releaseInitialReveal("degraded", "capacity"), null;
+          this.frozenCriticalRuns = r, this.initialRevealStartedAt = t, this.initialRevealPhase = "holding", this.publishInitialRevealProgress(r);
         } else {
           for (const l of [0, 1, 2]) {
-            const c = this.coarsenHomeRuns(r, l);
+            const c = this.coarsenHomeRuns(a, l);
             if (c.length !== 0) {
               if (this.criticalRunsFitCapacity(c)) {
-                a = c;
+                r = c;
                 break;
               }
-              a = c;
+              r = c;
             }
           }
-          if (a.length === 0)
+          if (r.length === 0)
             return this.initialRevealStateValue = { status: "ready" }, this.initialRevealPhase = "released", null;
-          if (!this.criticalRunsFitCapacity(a))
-            return this.frozenCriticalRuns = a, this.releaseInitialReveal("degraded", "capacity"), null;
-          this.frozenCriticalRuns = a, this.initialRevealStartedAt = t, this.initialRevealPhase = "holding", this.publishInitialRevealProgress(a);
+          if (!this.criticalRunsFitCapacity(r))
+            return this.frozenCriticalRuns = r, this.releaseInitialReveal("degraded", "capacity"), null;
+          this.frozenCriticalRuns = r, this.initialRevealStartedAt = t, this.initialRevealPhase = "holding", this.publishInitialRevealProgress(r);
         }
       }
     if (this.initialRevealPhase !== "holding" || !this.frozenCriticalRuns) return null;
     if (this.initialRevealStartedAt !== void 0 && t - this.initialRevealStartedAt >= ct)
       return this.releaseInitialReveal("degraded", "timeout"), null;
-    for (const r of this.frozenCriticalRuns)
-      if (this.failedFiles.has(r.file) && !this.resident.has(C(r))) {
-        const a = this.staged.get(C(r));
-        if (!a || a.uploadedCount !== r.count)
+    for (const a of this.frozenCriticalRuns)
+      if (this.failedFiles.has(a.file) && !this.resident.has(C(a))) {
+        const r = this.staged.get(C(a));
+        if (!r || r.uploadedCount !== a.count)
           return this.releaseInitialReveal("degraded", "fetch-failed"), null;
       }
     return this.publishInitialRevealProgress(this.frozenCriticalRuns), this.frozenCriticalRuns;
@@ -1805,18 +1839,18 @@ class Y extends Pe {
     return this.envFile !== void 0 && this.envEnabled && !this.envUnfit && this.envHandle === void 0 && !this.failedFiles.has(this.envFile);
   }
   /** Creates a performance event for a changed streamed-LOD tick, if any. */
-  createPerformanceEvent(e, t, s, n) {
-    let r = 0, a = 0;
-    for (const [u, g] of this.resident)
-      a += g.run.count, e.has(u) || (r += g.run.count);
+  createPerformanceEvent(e, t, i, n) {
+    let a = 0, r = 0;
+    for (const [d, g] of this.resident)
+      r += g.run.count, e.has(d) || (a += g.run.count);
     let l = 0;
-    for (const [u, g] of e)
-      this.resident.has(u) || (l += g);
+    for (const [d, g] of e)
+      this.resident.has(d) || (l += g);
     let c = 0;
-    for (const [u, g] of this.staged)
-      c += Math.max(0, g.uploadedCount - (t.get(u) ?? 0));
-    const h = this.compactionCount !== s;
-    if (r === 0 && l === 0 && c === 0 && !h) return null;
+    for (const [d, g] of this.staged)
+      c += Math.max(0, g.uploadedCount - (t.get(d) ?? 0));
+    const h = this.compactionCount !== i;
+    if (a === 0 && l === 0 && c === 0 && !h) return null;
     const f = performance.now();
     return {
       timestamp: f,
@@ -1826,73 +1860,73 @@ class Y extends Pe {
       sortSubmitMs: 0,
       stagingTextureAllocations: 0,
       activeListUpdateRanges: 0,
-      appendedCount: r,
+      appendedCount: a,
       removedCount: l,
       stagedCount: c,
-      uploadCount: r + c,
-      activeCount: a,
-      forcedSort: a === 0 || r + l >= a * ht,
+      uploadCount: a + c,
+      activeCount: r,
+      forcedSort: r === 0 || a + l >= r * ht,
       compacted: h
     };
   }
   /** Returns whether all new rows can coexist with the currently visible region. */
   canStageGroup(e) {
-    return e.adds.filter((s) => !this.staged.has(C(s))).reduce((s, n) => s + this.rowAlignedSplats(n.count), 0) <= this.freeSplatCapacity;
+    return e.adds.filter((i) => !this.staged.has(C(i))).reduce((i, n) => i + this.rowAlignedSplats(n.count), 0) <= this.freeSplatCapacity;
   }
   /**
    * Uploads a bounded part of a replacement without rendering it.
    * Skips runs whose chunks are not yet cached so siblings can stage out of order.
    */
-  stageGroup(e, t, s) {
-    if (s <= 0) return 0;
+  stageGroup(e, t, i) {
+    if (i <= 0) return 0;
     let n = 0;
-    for (const r of e.adds) {
-      const a = C(r), l = this.cache.get(r.file);
+    for (const a of e.adds) {
+      const r = C(a), l = this.cache.get(a.file);
       if (!l) continue;
-      let c = this.staged.get(a);
+      let c = this.staged.get(r);
       if (!c) {
         let f;
         try {
-          f = this.reserveInactiveRange(r.count);
+          f = this.reserveInactiveRange(a.count);
         } catch {
           this.compactionCount++, this.compact();
           try {
-            f = this.reserveInactiveRange(r.count);
+            f = this.reserveInactiveRange(a.count);
           } catch {
             this.pendingWork = !0;
             break;
           }
         }
-        c = { run: r, handle: f, uploadedCount: 0 }, this.staged.set(a, c);
+        c = { run: a, handle: f, uploadedCount: 0 }, this.staged.set(r, c);
       }
-      if (c.uploadedCount === r.count) continue;
-      const h = Math.min(r.count - c.uploadedCount, s - n);
+      if (c.uploadedCount === a.count) continue;
+      const h = Math.min(a.count - c.uploadedCount, i - n);
       if (h <= 0) break;
       if (this.writeInactiveRange(
         c.handle,
-        K(l.data, r.offset + c.uploadedCount, h),
+        K(l.data, a.offset + c.uploadedCount, h),
         c.uploadedCount
-      ), c.uploadedCount += h, l.lastUsed = t, n += h, c.uploadedCount === r.count) {
-        this.writeLodLevelChannel(c.handle, r.level);
-        for (const [f, u] of this.persistentChannels)
-          this.applyPersistentRun(f, u, r, c.handle);
+      ), c.uploadedCount += h, l.lastUsed = t, n += h, c.uploadedCount === a.count) {
+        this.writeLodLevelChannel(c.handle, a.level);
+        for (const [f, d] of this.persistentChannels)
+          this.applyPersistentRun(f, d, a, c.handle);
       }
-      if (n >= s) break;
+      if (n >= i) break;
     }
     return n;
   }
   /** Switches a fully staged region from old to new visibility in one tick. */
   commitStagedGroup(e) {
     for (const t of e.adds) {
-      const s = this.staged.get(C(t));
-      if (!s || s.uploadedCount !== t.count)
+      const i = this.staged.get(C(t));
+      if (!i || i.uploadedCount !== t.count)
         throw new Error("StreamedSplatMesh: incomplete staged group commit.");
     }
-    for (const [t, s] of e.removes)
-      this.resident.has(t) && (this.removeRange(s.handle), this.resident.delete(t));
+    for (const [t, i] of e.removes)
+      this.resident.has(t) && (this.removeRange(i.handle), this.resident.delete(t));
     for (const t of e.adds) {
-      const s = C(t), n = this.staged.get(s);
-      this.setRangeActive(n.handle, !0), this.resident.set(s, n), this.staged.delete(s);
+      const i = C(t), n = this.staged.get(i);
+      this.setRangeActive(n.handle, !0), this.resident.set(i, n), this.staged.delete(i);
     }
   }
   /**
@@ -1902,50 +1936,50 @@ class Y extends Pe {
    * removals - the caller defers it and the old runs keep rendering.
    */
   applyGroup(e, t) {
-    const s = (a) => Math.ceil(a / F) * F, n = e.adds.reduce((a, l) => a + s(l.count), 0), r = e.removes.reduce((a, [, l]) => a + s(l.run.count), 0);
-    if (n > this.freeSplatCapacity + r) return !1;
-    for (const [a, l] of e.removes)
-      this.resident.has(a) && (this.removeRange(l.handle), this.resident.delete(a));
-    for (const a of e.adds)
-      this.appendRun(a, t);
+    const i = (r) => Math.ceil(r / F) * F, n = e.adds.reduce((r, l) => r + i(l.count), 0), a = e.removes.reduce((r, [, l]) => r + i(l.run.count), 0);
+    if (n > this.freeSplatCapacity + a) return !1;
+    for (const [r, l] of e.removes)
+      this.resident.has(r) && (this.removeRange(l.handle), this.resident.delete(r));
+    for (const r of e.adds)
+      this.appendRun(r, t);
     return !0;
   }
   /** Appends one run from the cache, compacting the pool on fragmentation. */
   appendRun(e, t) {
-    const s = this.cache.get(e.file);
-    if (!s) return;
-    const n = K(s.data, e.offset, e.count);
-    let r;
+    const i = this.cache.get(e.file);
+    if (!i) return;
+    const n = K(i.data, e.offset, e.count);
+    let a;
     try {
-      r = this.appendRange(n);
+      a = this.appendRange(n);
     } catch {
       this.compactionCount++, this.compact();
       try {
-        r = this.appendRange(n);
+        a = this.appendRange(n);
       } catch {
         this.pendingWork = !0;
         return;
       }
     }
-    this.resident.set(C(e), { run: e, handle: r }), s.lastUsed = t, this.writeLodLevelChannel(r, e.level);
-    for (const [a, l] of this.persistentChannels)
-      this.applyPersistentRun(a, l, e, r);
+    this.resident.set(C(e), { run: e, handle: a }), i.lastUsed = t, this.writeLodLevelChannel(a, e.level);
+    for (const [r, l] of this.persistentChannels)
+      this.applyPersistentRun(r, l, e, a);
   }
   /**
    * Writes the stored edits for one run's `[offset, offset + count)` splats
    * into its freshly appended pool range. No-op when the file has no edits.
    */
-  applyPersistentRun(e, t, s, n) {
-    const r = t.edits.get(s.file);
-    if (!r || r.size === 0) return;
-    const a = t.type === "byte" ? new Uint8Array(s.count) : new Float32Array(s.count);
-    t.fill && a.fill(t.fill);
+  applyPersistentRun(e, t, i, n) {
+    const a = t.edits.get(i.file);
+    if (!a || a.size === 0) return;
+    const r = t.type === "byte" ? new Uint8Array(i.count) : new Float32Array(i.count);
+    t.fill && r.fill(t.fill);
     let l = !1;
-    for (let c = 0; c < s.count; c++) {
-      const h = r.get(s.offset + c);
-      h !== void 0 && (a[c] = h, l = !0);
+    for (let c = 0; c < i.count; c++) {
+      const h = a.get(i.offset + c);
+      h !== void 0 && (r[c] = h, l = !0);
     }
-    l && this.writeChannel(n, e, a);
+    l && this.writeChannel(n, e, r);
   }
   /**
    * Covers a deferred group's leaves that no resident run covers with each
@@ -1958,21 +1992,21 @@ class Y extends Pe {
    * paint and its pin fetch entirely - cold load requests only the target cut
    * for that cell. Far gaps keep the shell.
    */
-  substituteCoverage(e, t, s, n) {
-    const r = e.leafEnd - e.leafStart;
-    (this.coverageScratch === void 0 || this.coverageScratch.length < r) && (this.coverageScratch = new Uint8Array(r));
-    const a = this.coverageScratch;
-    a.fill(0, 0, r);
+  substituteCoverage(e, t, i, n) {
+    const a = e.leafEnd - e.leafStart;
+    (this.coverageScratch === void 0 || this.coverageScratch.length < a) && (this.coverageScratch = new Uint8Array(a));
+    const r = this.coverageScratch;
+    r.fill(0, 0, a);
     for (const { run: h } of this.resident.values()) {
-      const f = Math.max(h.leafStart, e.leafStart), u = Math.min(h.leafEnd, e.leafEnd);
-      u > f && a.fill(1, f - e.leafStart, u - e.leafStart);
+      const f = Math.max(h.leafStart, e.leafStart), d = Math.min(h.leafEnd, e.leafEnd);
+      d > f && r.fill(1, f - e.leafStart, d - e.leafStart);
     }
-    const l = a.subarray(0, r);
+    const l = r.subarray(0, a);
     let c = 0;
-    for (; c < r; ) {
+    for (; c < a; ) {
       const h = l.indexOf(0, c);
       if (h < 0) break;
-      const f = l.indexOf(1, h), u = f < 0 ? r : f, g = e.leafStart + h, v = e.leafStart + u;
+      const f = l.indexOf(1, h), d = f < 0 ? a : f, g = e.leafStart + h, v = e.leafStart + d;
       for (const m of this.scene.source.coarsestRunsFor(g, v))
         if (!this.resident.has(C(m))) {
           if (n) {
@@ -1981,7 +2015,7 @@ class Y extends Pe {
           }
           if (!this.cache.has(m.file)) {
             oe(
-              s,
+              i,
               m.file,
               je(m, this.scene.source.lodBaseDistance),
               m
@@ -1992,18 +2026,18 @@ class Y extends Pe {
             T.run.leafStart < m.leafEnd && T.run.leafEnd > m.leafStart && (this.removeRange(T.handle), this.resident.delete(b));
           this.appendRun(m, t);
         }
-      c = u;
+      c = d;
     }
   }
   /** Issues pending classic-path chunk wants in group-priority order. */
-  flushClassicFetches(e, t, s = !1) {
+  flushClassicFetches(e, t, i = !1) {
     if (e.size === 0) return;
-    $e(e, t, s);
+    $e(e, t, i);
     const n = [...e.entries()].sort(
-      (r, a) => X(r[1], a[1], r[0], a[0])
+      (a, r) => X(a[1], r[1], a[0], r[0])
     );
     this.preemptClassicFetches(n);
-    for (const [r, a] of n) this.requestChunk(r, a.kind, a);
+    for (const [a, r] of n) this.requestChunk(a, r.kind, r);
   }
   /**
    * A camera turn must not wait for all eight old visible requests to finish.
@@ -2012,12 +2046,12 @@ class Y extends Pe {
    */
   preemptClassicFetches(e) {
     var t;
-    for (const [s, n] of e) {
-      if (this.cache.has(s) || this.fetching.has(s)) continue;
-      let r, a;
+    for (const [i, n] of e) {
+      if (this.cache.has(i) || this.fetching.has(i)) continue;
+      let a, r;
       for (const [l, c] of this.fetching)
-        c.classicWant && (!a || X(c.classicWant, a, l, r) > 0) && (r = l, a = c.classicWant);
-      if (a && r !== void 0 && X(n, a, s, r) < 0 && ((t = this.fetching.get(r)) == null || t.controller.abort()), this.fetching.size >= this.maxInflight) return;
+        c.classicWant && (!r || X(c.classicWant, r, l, a) > 0) && (a = l, r = c.classicWant);
+      if (r && a !== void 0 && X(n, r, i, a) < 0 && ((t = this.fetching.get(a)) == null || t.controller.abort()), this.fetching.size >= this.maxInflight) return;
     }
   }
   /**
@@ -2029,38 +2063,38 @@ class Y extends Pe {
    * it issues ahead of LOD coverage.
    */
   updateEnvironment(e, t) {
-    const s = this.envFile;
-    if (s === void 0 || this.envHandle !== void 0 || !this.envEnabled || this.envUnfit)
+    const i = this.envFile;
+    if (i === void 0 || this.envHandle !== void 0 || !this.envEnabled || this.envUnfit)
       return;
-    const n = this.cache.get(s);
+    const n = this.cache.get(i);
     if (!n) {
-      this.failedFiles.has(s) || (t ? this.enqueueEnvironmentFetch(t, s) : this.requestChunk(s, "priority"), this.pendingWork = !0);
+      this.failedFiles.has(i) || (t ? this.enqueueEnvironmentFetch(t, i) : this.requestChunk(i, "priority"), this.pendingWork = !0);
       return;
     }
-    const r = Math.ceil(n.data.count / F) * F;
-    if (r > this.capacity) {
-      this.envUnfit = !0, P(
+    const a = Math.ceil(n.data.count / F) * F;
+    if (a > this.capacity) {
+      this.envUnfit = !0, E(
         `the environment tile (${n.data.count} splats) exceeds the pool capacity (${this.capacity}); it will not be shown. Raise the splat budget to fit it.`
       );
       return;
     }
-    if (r > this.freeSplatCapacity) {
+    if (a > this.freeSplatCapacity) {
       this.pendingWork = !0;
       return;
     }
-    let a;
+    let r;
     try {
-      a = this.appendRange(n.data);
+      r = this.appendRange(n.data);
     } catch {
       this.compactionCount++, this.compact();
       try {
-        a = this.appendRange(n.data);
+        r = this.appendRange(n.data);
       } catch {
         this.pendingWork = !0;
         return;
       }
     }
-    this.envHandle = a, this.envSplatCount = n.data.count, n.lastUsed = e;
+    this.envHandle = r, this.envSplatCount = n.data.count, n.lastUsed = e;
   }
   /** Ranks the env tile ahead of every LOD want in {@link flushClassicFetches}. */
   enqueueEnvironmentFetch(e, t) {
@@ -2089,16 +2123,16 @@ class Y extends Pe {
    * with a paging plan. Coalesced to one outstanding request so the main thread
    * never blocks. Also drives chunk fetching, in priority order.
    */
-  reschedulePageTable(e, t, s, n) {
-    for (const a of this.pageTableFetchPriority) this.requestChunk(a, "priority");
-    const r = new Set(this.pageTableFetchPriority);
-    for (const a of this.scene.source.computeDesiredRuns(e, s, n))
-      r.add(a.file), this.requestChunk(a.file, "base");
-    for (const [a, l] of this.fetching)
-      l.kind !== "sweep" && !r.has(a) && !this.scene.pinnedFiles.has(a) && l.controller.abort();
+  reschedulePageTable(e, t, i, n) {
+    for (const r of this.pageTableFetchPriority) this.requestChunk(r, "priority");
+    const a = new Set(this.pageTableFetchPriority);
+    for (const r of this.scene.source.computeDesiredRuns(e, i, n))
+      a.add(r.file), this.requestChunk(r.file, "base");
+    for (const [r, l] of this.fetching)
+      l.kind !== "sweep" && !a.has(r) && !this.scene.pinnedFiles.has(r) && l.controller.abort();
     if (!this.pageTableCacheAtLimit && this.sweepAllowed()) {
-      const a = Math.max(1, this.maxInflight - mt), l = this.scene.chunkUrls.length;
-      for (let c = 0; c < l && this.fetching.size < a; c++)
+      const r = Math.max(1, this.maxInflight - mt), l = this.scene.chunkUrls.length;
+      for (let c = 0; c < l && this.fetching.size < r; c++)
         this.pageTableCachedFiles.has(c) || this.requestChunk(c, "sweep");
     }
     this.pageTableInFlight || (this.pageTableInFlight = !0, this.postToWorker({
@@ -2123,48 +2157,48 @@ class Y extends Pe {
     if (this.pageTableInFlight = !1, this.pageTableDisposed || this.slabPages.length === 0) return;
     const t = this.pagerSlots;
     e.capacity !== t && (this.pendingWork = !0, this.lastScheduleTime = -1 / 0);
-    const s = performance.now(), n = e.moveSlots;
-    for (let u = 0; u < n.length; ) {
+    const i = performance.now(), n = e.moveSlots;
+    for (let d = 0; d < n.length; ) {
       let g = 1;
-      for (; u + g < n.length && n[u + g] === n[u] + g; )
+      for (; d + g < n.length && n[d + g] === n[d] + g; )
         g++;
-      const v = n[u], m = Math.min(g, t - v);
-      m > 0 && this.writeSlabSlots(yt(e.moves, u, m), v, m), u += g;
+      const v = n[d], m = Math.min(g, t - v);
+      m > 0 && this.writeSlabSlots(yt(e.moves, d, m), v, m), d += g;
     }
     if (e.appends.count > 0) {
-      const u = Math.min(e.appends.count, t - e.appendStart);
-      u > 0 && this.writeSlabSlots(e.appends, e.appendStart, u);
+      const d = Math.min(e.appends.count, t - e.appendStart);
+      d > 0 && this.writeSlabSlots(e.appends, e.appendStart, d);
     }
-    const r = performance.now(), a = Math.min(e.residentCount, t);
-    this.setSlabResident(a);
+    const a = performance.now(), r = Math.min(e.residentCount, t);
+    this.setSlabResident(r);
     const l = Math.min(e.degenerateStart, t), c = Math.min(e.degenerateCount, t - l);
     c > 0 && this.degenerateSlabSlots(l, c);
     const h = performance.now();
-    this.pageTableDrawn = a, e.gatherMissing > 0 && P(
+    this.pageTableDrawn = r, this.frontierConverged = e.converged, this.pendingFrontierSplats = e.pendingFrontierSplats ?? 0, this.staleResidentSplats = e.staleResidentSplats ?? 0, this.lastPlanAppends = e.lastPlanAppends ?? e.appends.count, this.lastPlanMoves = e.lastPlanMoves ?? e.moveSlots.length, this.lastPlanGeneration = e.planGeneration ?? this.lastPlanGeneration + 1, this.lastPlanBudget = e.planBudget ?? this.pageTableDrawBudget, e.cameraLocal && (this.lastPlanCamera = e.cameraLocal, this.firstFrontierCamera ?? (this.firstFrontierCamera = e.cameraLocal)), e.gatherMissing > 0 && E(
       `StreamedSplatMesh: page-table plan gathered ${e.gatherMissing} splats from evicted chunks; they render as holes.`
     );
     const f = this.planTimingsValue;
-    if (f.applyMs = h - s, f.writeMs = r - s, f.residentMs = h - r, f.moves = e.moveSlots.length, f.appends = e.appends.count, f.applyMs > f.worstApplyMs && (f.worstApplyMs = f.applyMs, f.worstSplats = f.moves + f.appends), this.frontierBandBase !== null && e.solvedLimit > 0 && this.pageTableLimit > 0) {
-      const u = Math.min(1, e.solvedLimit / this.pageTableLimit);
+    if (f.applyMs = h - i, f.writeMs = a - i, f.residentMs = h - a, f.moves = e.moveSlots.length, f.appends = e.appends.count, f.applyMs > f.worstApplyMs && (f.worstApplyMs = f.applyMs, f.worstSplats = f.moves + f.appends), this.frontierBandBase !== null && e.solvedLimit > 0 && this.pageTableLimit > 0) {
+      const d = Math.min(1, e.solvedLimit / this.pageTableLimit);
       this.setScreenRadiusBand(
-        this.frontierBandBase.min * u,
-        this.frontierBandBase.max * u
+        this.frontierBandBase.min * d,
+        this.frontierBandBase.max * d
       );
     }
-    this.invalidateSort(), e.dropped > 0 && P(
+    this.invalidateSort(), e.dropped > 0 && E(
       `StreamedSplatMesh: page-table slab full, dropped ${e.dropped} frontier splats (draw budget ${this.pageTableDrawBudget} exceeds the pool).`
     );
-    for (let u = 0; u < e.evicted.length; u++)
-      this.pageTableCachedFiles.delete(e.evicted[u]);
+    for (let d = 0; d < e.evicted.length; d++)
+      this.pageTableCachedFiles.delete(e.evicted[d]);
     this.fetchCountsValue.cacheBytes = e.cacheBytes, this.fetchCountsValue.cacheLimitBytes = e.cacheLimitBytes, this.pageTableCacheAtLimit = e.cacheBytes >= e.cacheLimitBytes, e.evicted.length > 0 && (this.fetchCountsValue.cacheFull = !0, this.fetchCountsValue.evicted += e.evicted.length), this.pageTableFetchPriority = Array.from(e.touched);
-    for (const u of this.pageTableFetchPriority) this.requestChunk(u, "priority");
+    for (const d of this.pageTableFetchPriority) this.requestChunk(d, "priority");
     (this.fetching.size > 0 || !e.converged) && (this.pendingWork = !0, e.converged || (this.lastScheduleTime = -1 / 0));
   }
   /** Forwards a decoded chunk's arrays to the worker (buffers transferred) so the
    * worker's cache/traversal/gather can use it. */
   forwardChunkToWorker(e, t) {
-    const s = t.radTree;
-    if (!s) return;
+    const i = t.radTree;
+    if (!i) return;
     this.pageTableCachedFiles.add(e);
     const n = this.shBands > 0 ? t.shPacked : void 0;
     this.postToWorker(
@@ -2175,9 +2209,9 @@ class Y extends Pe {
         positions: t.positions,
         colors: t.colors,
         covariances: t.covariances,
-        childCount: s.childCount,
-        childStart: s.childStart,
-        size: s.size,
+        childCount: i.childCount,
+        childStart: i.childStart,
+        size: i.size,
         shBands: (n == null ? void 0 : n.bands) ?? 0,
         ...n ? { shPacked: n.packed, shRange: n.range } : {}
       },
@@ -2185,9 +2219,9 @@ class Y extends Pe {
         t.positions.buffer,
         t.colors.buffer,
         t.covariances.buffer,
-        s.childCount.buffer,
-        s.childStart.buffer,
-        s.size.buffer,
+        i.childCount.buffer,
+        i.childStart.buffer,
+        i.size.buffer,
         ...n ? [n.packed.buffer] : []
       ]
     );
@@ -2196,7 +2230,7 @@ class Y extends Pe {
    * per-host cap simply queues. Same cap for classic and page-table so near
    * detail is not structurally starved on the non-page-table path. */
   get maxInflight() {
-    return ut;
+    return dt;
   }
   /**
    * Whether this mesh may run its speculative background sweep. A mesh with no
@@ -2226,33 +2260,33 @@ class Y extends Pe {
     for (const t of this.fetching.values())
       t.kind === e && t.controller.abort();
   }
-  requestChunk(e, t, s) {
+  requestChunk(e, t, i) {
     var l, c;
     if (this.cache.has(e) || this.pageTableCachedFiles.has(e) || this.fetching.has(e) || this.fetching.size >= this.maxInflight || this.failedFiles.has(e)) return;
     const n = this.retrying.get(e);
     if (n && performance.now() < n.readyAt) return;
     this.fetchCountsValue[t]++;
-    const r = this.scene.chunkUrls[e];
-    if (r === void 0) {
-      P(`StreamedSplatMesh: manifest references unknown chunk file #${e}.`), this.failedFiles.add(e);
+    const a = this.scene.chunkUrls[e];
+    if (a === void 0) {
+      E(`StreamedSplatMesh: manifest references unknown chunk file #${e}.`), this.failedFiles.add(e);
       return;
     }
     if (this.fetchHandle && !((l = this.fetchScheduler) != null && l.tryAcquire(this.fetchHandle, t))) return;
-    const a = new AbortController();
-    this.fetching.set(e, { controller: a, kind: t, classicWant: s }), this.loader.load(r, {
+    const r = new AbortController();
+    this.fetching.set(e, { controller: r, kind: t, classicWant: i }), this.loader.load(a, {
       kind: this.scene.chunkKind,
-      signal: a.signal,
+      signal: r.signal,
       ...(c = this.scene.chunkOptions) == null ? void 0 : c[e]
     }).then((h) => {
-      var f, u;
-      this.disposed || (this.retrying.delete(e), (u = (f = this.scene.source).onChunkDecoded) == null || u.call(f, e, h), this.frontierWorker ? (this.forwardChunkToWorker(e, h), this.pendingWork = !0) : this.cacheChunk(e, h));
+      var f, d;
+      this.disposed || (this.retrying.delete(e), (d = (f = this.scene.source).onChunkDecoded) == null || d.call(f, e, h), this.frontierWorker ? (this.forwardChunkToWorker(e, h), this.pendingWork = !0) : this.cacheChunk(e, h));
     }).catch((h) => {
-      var u;
-      if (G(h)) return;
-      const f = (((u = this.retrying.get(e)) == null ? void 0 : u.attempts) ?? 0) + 1;
+      var d;
+      if (N(h)) return;
+      const f = (((d = this.retrying.get(e)) == null ? void 0 : d.attempts) ?? 0) + 1;
       if (f >= gt)
-        this.retrying.delete(e), this.failedFiles.add(e), P(
-          `StreamedSplatMesh: gave up on chunk #${e} (${r}) after ${f} attempts.`,
+        this.retrying.delete(e), this.failedFiles.add(e), E(
+          `StreamedSplatMesh: gave up on chunk #${e} (${a}) after ${f} attempts.`,
           h
         );
       else {
@@ -2270,40 +2304,40 @@ class Y extends Pe {
    * of {@link cache} (this method, eviction, dispose's clear) maintains it.
    */
   cacheChunk(e, t) {
-    const s = this.cache.get(e);
-    s !== void 0 && (this.cacheBytesTotal -= s.bytes);
+    const i = this.cache.get(e);
+    i !== void 0 && (this.cacheBytesTotal -= i.bytes);
     const n = Xe(t);
     this.cache.set(e, { data: t, bytes: n, lastUsed: performance.now() }), this.cacheBytesTotal += n;
   }
   evictChunks(e) {
     let t = this.cacheBytesTotal;
     if (t <= this.cpuCacheBytes) return;
-    const s = [...this.cache.entries()].filter(
-      ([n, r]) => r.lastUsed !== e && !this.scene.pinnedFiles.has(n) && !this.neededFiles.has(n)
-    ).sort((n, r) => n[1].lastUsed - r[1].lastUsed);
-    for (const [n, r] of s) {
+    const i = [...this.cache.entries()].filter(
+      ([n, a]) => a.lastUsed !== e && !this.scene.pinnedFiles.has(n) && !this.neededFiles.has(n)
+    ).sort((n, a) => n[1].lastUsed - a[1].lastUsed);
+    for (const [n, a] of i) {
       if (t <= this.cpuCacheBytes) break;
-      this.cache.delete(n), this.cacheBytesTotal -= r.bytes, t -= r.bytes, this.fetchCountsValue.evicted++;
+      this.cache.delete(n), this.cacheBytesTotal -= a.bytes, t -= a.bytes, this.fetchCountsValue.evicted++;
     }
   }
 }
-const V = new w.Vector3(), pe = new w.Vector3(), me = new w.Quaternion(), x = new w.Vector3(), ve = new w.Matrix4(), z = new w.Frustum(), wt = new w.Sphere(), B = new w.Vector3(), Se = new w.Vector2();
+const V = new w.Vector3(), pe = new w.Vector3(), me = new w.Quaternion(), x = new w.Vector3(), ve = new w.Matrix4(), O = new w.Frustum(), wt = new w.Sphere(), B = new w.Vector3(), Se = new w.Vector2();
 function be(o) {
   return Math.ceil(3 * Ie(o) / 4);
 }
-function yt(o, i, e) {
+function yt(o, s, e) {
   const t = o.shPacked;
   return {
     count: e,
-    positions: o.positions.subarray(i * 3, (i + e) * 3),
-    colors: o.colors.subarray(i * 4, (i + e) * 4),
-    covariances: o.covariances.subarray(i * 6, (i + e) * 6),
+    positions: o.positions.subarray(s * 3, (s + e) * 3),
+    colors: o.colors.subarray(s * 4, (s + e) * 4),
+    covariances: o.covariances.subarray(s * 6, (s + e) * 6),
     ...t ? {
       shPacked: {
         ...t,
         packed: t.packed.subarray(
-          i * be(t.bands),
-          (i + e) * be(t.bands)
+          s * be(t.bands),
+          (s + e) * be(t.bands)
         )
       }
     } : {}
@@ -2311,12 +2345,12 @@ function yt(o, i, e) {
 }
 const Ct = 1;
 class Tt {
-  constructor(i = {}) {
-    d(this, "entries", /* @__PURE__ */ new Map());
-    d(this, "total");
-    d(this, "hysteresis");
-    this.total = W(i.totalBudget);
-    const e = i.hysteresis ?? 0.1;
+  constructor(s = {}) {
+    u(this, "entries", /* @__PURE__ */ new Map());
+    u(this, "total");
+    u(this, "hysteresis");
+    this.total = W(s.totalBudget);
+    const e = s.hysteresis ?? 0.1;
     if (!Number.isFinite(e) || e < 0)
       throw new RangeError("BudgetGovernor hysteresis must be a non-negative finite number.");
     this.hysteresis = e;
@@ -2326,8 +2360,8 @@ class Tt {
     return this.total;
   }
   /** Replaces the shared total and reallocates. */
-  setTotalBudget(i) {
-    const e = W(i);
+  setTotalBudget(s) {
+    const e = W(s);
     e !== this.total && (this.total = e, this.reallocate());
   }
   /** Number of registered members. */
@@ -2343,15 +2377,15 @@ class Tt {
    * proportional to its weight - e.g. main mesh `7`, additional mesh `3` reproduces
    * the old 0.7 host split. `0` registers the member suspended.
    */
-  register(i, e = {}) {
-    if (this.entries.has(i))
+  register(s, e = {}) {
+    if (this.entries.has(s))
       throw new Error("BudgetGovernor: member is already registered.");
     const t = J(e.weight ?? 1);
-    this.entries.set(i, {
-      member: i,
+    this.entries.set(s, {
+      member: s,
       weight: t,
-      applied: i.budget,
-      restoreBudget: i.budget
+      applied: s.budget,
+      restoreBudget: s.budget
     }), this.reallocate();
   }
   /**
@@ -2359,17 +2393,17 @@ class Tt {
    * reallocates the total across the remaining members. No-op for a member
    * that is not registered (so disposing hosts need not track membership).
    */
-  unregister(i) {
-    const e = this.entries.get(i);
-    e !== void 0 && (this.entries.delete(i), e.member.setBudget(e.restoreBudget), this.reallocate());
+  unregister(s) {
+    const e = this.entries.get(s);
+    e !== void 0 && (this.entries.delete(s), e.member.setBudget(e.restoreBudget), this.reallocate());
   }
   /**
    * Changes a member's priority weight and reallocates. `0` suspends the
    * member (see the class doc); any positive weight resumes it.
    */
-  setWeight(i, e) {
-    const t = this.entryOf(i), s = J(e);
-    s !== t.weight && (t.weight = s, this.reallocate());
+  setWeight(s, e) {
+    const t = this.entryOf(s), i = J(e);
+    i !== t.weight && (t.weight = i, this.reallocate());
   }
   /**
    * Writes several weights, then reallocates **once**.
@@ -2386,19 +2420,19 @@ class Tt {
    * is written, so a bad pair leaves every weight untouched.
    * @throws {RangeError} if any weight is not a non-negative finite number.
    */
-  setWeights(i) {
-    const e = [...i].map(
-      ([s, n]) => [this.entryOf(s), J(n)]
+  setWeights(s) {
+    const e = [...s].map(
+      ([i, n]) => [this.entryOf(i), J(n)]
     );
     let t = !1;
-    for (const [s, n] of e)
-      s.weight !== n && (s.weight = n, t = !0);
+    for (const [i, n] of e)
+      i.weight !== n && (i.weight = n, t = !0);
     t && this.reallocate();
   }
   /** The budget the governor last applied to a member, if registered. */
-  budgetOf(i) {
+  budgetOf(s) {
     var e;
-    return (e = this.entries.get(i)) == null ? void 0 : e.applied;
+    return (e = this.entries.get(s)) == null ? void 0 : e.applied;
   }
   /**
    * Recomputes and applies every member's share. Called automatically by all
@@ -2406,19 +2440,19 @@ class Tt {
    * outside the governor's view.
    */
   reallocate() {
-    let i = [];
+    let s = [];
     for (const t of this.entries.values())
-      t.weight === 0 ? this.applyTarget(t, Ct) : i.push(t);
+      t.weight === 0 ? this.applyTarget(t, Ct) : s.push(t);
     let e = this.total;
-    for (; i.length > 0; ) {
-      const t = i.reduce((r, a) => r + a.weight, 0), s = [];
+    for (; s.length > 0; ) {
+      const t = s.reduce((a, r) => a + r.weight, 0), i = [];
       let n = 0;
-      for (const r of i) {
-        const a = Math.max(1, Math.floor(e * r.weight / t));
-        this.applyTarget(r, a) && (s.push(r), n += r.applied);
+      for (const a of s) {
+        const r = Math.max(1, Math.floor(e * a.weight / t));
+        this.applyTarget(a, r) && (i.push(a), n += a.applied);
       }
-      if (s.length === 0) break;
-      e = Math.max(0, e - n), i = i.filter((r) => !s.includes(r));
+      if (i.length === 0) break;
+      e = Math.max(0, e - n), s = s.filter((a) => !i.includes(a));
     }
   }
   /**
@@ -2426,13 +2460,13 @@ class Tt {
    * The governor itself stays usable (dispose is just "unregister everyone").
    */
   dispose() {
-    for (const i of this.entries.values())
-      i.member.setBudget(i.restoreBudget);
+    for (const s of this.entries.values())
+      s.member.setBudget(s.restoreBudget);
     this.entries.clear();
   }
   /** The entry for a registered member, or a thrown error naming the problem. */
-  entryOf(i) {
-    const e = this.entries.get(i);
+  entryOf(s) {
+    const e = this.entries.get(s);
     if (e === void 0)
       throw new Error("BudgetGovernor: member is not registered.");
     return e;
@@ -2441,12 +2475,12 @@ class Tt {
    * Pushes `target` to a member, with the grow dead-band. Returns true when
    * the member clamped below its target (it is capped and cannot absorb more).
    */
-  applyTarget(i, e) {
-    if (e > i.applied) {
-      if (e - i.applied <= this.hysteresis * i.applied) return !1;
-    } else if (e === i.applied)
+  applyTarget(s, e) {
+    if (e > s.applied) {
+      if (e - s.applied <= this.hysteresis * s.applied) return !1;
+    } else if (e === s.applied)
       return !1;
-    return i.applied = i.member.setBudget(e), i.applied < e;
+    return s.applied = s.member.setBudget(e), s.applied < e;
   }
 }
 function J(o) {
@@ -2456,21 +2490,21 @@ function J(o) {
     );
   return o;
 }
-const we = new w.Vector3(), ye = new w.Matrix4(), Ce = new w.Frustum(), Z = new w.Box3(), O = new w.Sphere();
-class Ot {
-  constructor(i = {}) {
-    d(this, "entries", /* @__PURE__ */ new Map());
-    d(this, "budgetGovernor");
-    d(this, "minIntervalMs");
-    d(this, "weightDeadband");
-    d(this, "falloff");
-    d(this, "offScreenWeight");
-    d(this, "minWeight");
-    d(this, "maxWeight");
-    d(this, "lastUpdateAt", -1 / 0);
+const we = new w.Vector3(), ye = new w.Matrix4(), Ce = new w.Frustum(), Z = new w.Box3(), z = new w.Sphere();
+class zt {
+  constructor(s = {}) {
+    u(this, "entries", /* @__PURE__ */ new Map());
+    u(this, "budgetGovernor");
+    u(this, "minIntervalMs");
+    u(this, "weightDeadband");
+    u(this, "falloff");
+    u(this, "offScreenWeight");
+    u(this, "minWeight");
+    u(this, "maxWeight");
+    u(this, "lastUpdateAt", -1 / 0);
     /** Set by membership/priority changes: the next update ignores both damps. */
-    d(this, "forceNext", !0);
-    if (this.budgetGovernor = i.governor ?? new Tt(i), this.minIntervalMs = N(i.minIntervalMs ?? 250, "minIntervalMs"), this.weightDeadband = N(i.weightDeadband ?? 0.15, "weightDeadband"), this.falloff = U(i.falloff ?? 1, "falloff"), this.offScreenWeight = U(i.offScreenWeight ?? 0.25, "offScreenWeight"), this.minWeight = U(i.minWeight ?? 0.05, "minWeight"), this.maxWeight = U(i.maxWeight ?? 8, "maxWeight"), this.maxWeight < this.minWeight)
+    u(this, "forceNext", !0);
+    if (this.budgetGovernor = s.governor ?? new Tt(s), this.minIntervalMs = D(s.minIntervalMs ?? 250, "minIntervalMs"), this.weightDeadband = D(s.weightDeadband ?? 0.15, "weightDeadband"), this.falloff = U(s.falloff ?? 1, "falloff"), this.offScreenWeight = U(s.offScreenWeight ?? 0.25, "offScreenWeight"), this.minWeight = U(s.minWeight ?? 0.05, "minWeight"), this.maxWeight = U(s.maxWeight ?? 8, "maxWeight"), this.maxWeight < this.minWeight)
       throw new RangeError("CameraBudgetGovernor maxWeight must be >= minWeight.");
   }
   /** The governor this drives; use it for fixed-weight members and diagnostics. */
@@ -2482,8 +2516,8 @@ class Ot {
     return this.budgetGovernor.totalBudget;
   }
   /** Replaces the shared total (e.g. the presenting budget on `sessionstart`). */
-  setTotalBudget(i) {
-    this.budgetGovernor.setTotalBudget(i);
+  setTotalBudget(s) {
+    this.budgetGovernor.setTotalBudget(s);
   }
   /** Number of camera-weighted members. */
   get size() {
@@ -2496,18 +2530,18 @@ class Ot {
    * @throws {Error} if the member is already registered here.
    * @throws {RangeError} if `priority` or `fixedWeight` is invalid.
    */
-  register(i, e = {}) {
-    if (this.entries.has(i))
+  register(s, e = {}) {
+    if (this.entries.has(s))
       throw new Error("CameraBudgetGovernor: member is already registered.");
-    const t = N(e.priority ?? 1, "priority"), s = e.fixedWeight === void 0 ? void 0 : N(e.fixedWeight, "fixedWeight"), n = s ?? t;
-    this.budgetGovernor.register(i, { weight: n }), this.entries.set(i, { member: i, priority: t, fixedWeight: s, applied: n }), this.forceNext = !0;
+    const t = D(e.priority ?? 1, "priority"), i = e.fixedWeight === void 0 ? void 0 : D(e.fixedWeight, "fixedWeight"), n = i ?? t;
+    this.budgetGovernor.register(s, { weight: n }), this.entries.set(s, { member: s, priority: t, fixedWeight: i, applied: n }), this.forceNext = !0;
   }
   /**
    * Removes a member from this helper and the underlying governor, restoring
    * the budget it had when it joined. No-op for an unknown member.
    */
-  unregister(i) {
-    this.entries.delete(i) && (this.budgetGovernor.unregister(i), this.forceNext = !0);
+  unregister(s) {
+    this.entries.delete(s) && (this.budgetGovernor.unregister(s), this.forceNext = !0);
   }
   /**
    * Changes a member's priority tier. Takes effect on the next {@link update},
@@ -2517,12 +2551,12 @@ class Ot {
    * @throws {Error} if the member is not registered here.
    * @throws {RangeError} if `priority` is negative or not finite.
    */
-  setPriority(i, e) {
-    const t = this.entries.get(i);
+  setPriority(s, e) {
+    const t = this.entries.get(s);
     if (t === void 0)
       throw new Error("CameraBudgetGovernor: member is not registered.");
-    const s = N(e, "priority");
-    s !== t.priority && (t.priority = s, this.forceNext = !0);
+    const i = D(e, "priority");
+    i !== t.priority && (t.priority = i, this.forceNext = !0);
   }
   /**
    * Recomputes every member's weight from the camera and applies them in one
@@ -2539,33 +2573,33 @@ class Ot {
    * @param now - Timestamp in ms on the `performance.now` clock; defaults to it.
    * @returns whether weights were reapplied.
    */
-  update(i, e = performance.now()) {
+  update(s, e = performance.now()) {
     if (this.entries.size === 0) return !1;
     const t = this.forceNext;
     if (!t && e - this.lastUpdateAt < this.minIntervalMs) return !1;
-    i.updateMatrixWorld(), i.getWorldPosition(we), ye.multiplyMatrices(i.projectionMatrix, i.matrixWorldInverse), Ce.setFromProjectionMatrix(ye);
-    const s = [];
+    s.updateMatrixWorld(), s.getWorldPosition(we), ye.multiplyMatrices(s.projectionMatrix, s.matrixWorldInverse), Ce.setFromProjectionMatrix(ye);
+    const i = [];
     let n = !1;
-    for (const r of this.entries.values()) {
-      const a = this.weightFor(r);
-      s.push([r.member, a]), !n && this.isSignificant(r.applied, a) && (n = !0);
+    for (const a of this.entries.values()) {
+      const r = this.weightFor(a);
+      i.push([a.member, r]), !n && this.isSignificant(a.applied, r) && (n = !0);
     }
     if (!t && !n) return !1;
-    this.budgetGovernor.setWeights(s);
-    for (const [r, a] of s) {
-      const l = this.entries.get(r);
-      l !== void 0 && (l.applied = a);
+    this.budgetGovernor.setWeights(i);
+    for (const [a, r] of i) {
+      const l = this.entries.get(a);
+      l !== void 0 && (l.applied = r);
     }
     return this.lastUpdateAt = e, this.forceNext = !1, !0;
   }
   /** The weight currently written for a member, if registered here. */
-  weightOf(i) {
+  weightOf(s) {
     var e;
-    return (e = this.entries.get(i)) == null ? void 0 : e.applied;
+    return (e = this.entries.get(s)) == null ? void 0 : e.applied;
   }
   /** The budget the underlying governor last applied to a member. */
-  budgetOf(i) {
-    return this.budgetGovernor.budgetOf(i);
+  budgetOf(s) {
+    return this.budgetGovernor.budgetOf(s);
   }
   /**
    * Unregisters every member, restoring the budget each had when it joined.
@@ -2573,7 +2607,7 @@ class Ot {
    * any members the host registered on it directly.
    */
   dispose() {
-    for (const i of [...this.entries.keys()]) this.budgetGovernor.unregister(i);
+    for (const s of [...this.entries.keys()]) this.budgetGovernor.unregister(s);
     this.entries.clear(), this.lastUpdateAt = -1 / 0, this.forceNext = !0;
   }
   /**
@@ -2587,49 +2621,49 @@ class Ot {
    * distant center, and is floored so a camera inside the bounds saturates at
    * `maxWeight` rather than dividing by zero.
    */
-  weightFor(i) {
-    if (i.fixedWeight !== void 0) return i.fixedWeight;
-    const { member: e, priority: t } = i;
+  weightFor(s) {
+    if (s.fixedWeight !== void 0) return s.fixedWeight;
+    const { member: e, priority: t } = s;
     if (t === 0 || !(e.effectiveVisibility ?? e.visible)) return 0;
     if (e.updateWorldMatrix(!0, !1), Z.copy(e.computeSplatBounds()), Z.isEmpty()) return t * this.minWeight;
-    Z.applyMatrix4(e.matrixWorld).getBoundingSphere(O);
-    const s = O.radius;
-    if (!(s > 0)) return t * this.minWeight;
-    const n = O.center.distanceTo(we) - s, r = Math.max(n, s * 1e-3, 1e-6), a = It((s / r) ** this.falloff, this.minWeight, this.maxWeight);
-    if (!Number.isFinite(a)) return t * this.minWeight;
-    const l = Ce.intersectsSphere(O) ? 1 : this.offScreenWeight;
-    return t * a * l;
+    Z.applyMatrix4(e.matrixWorld).getBoundingSphere(z);
+    const i = z.radius;
+    if (!(i > 0)) return t * this.minWeight;
+    const n = z.center.distanceTo(we) - i, a = Math.max(n, i * 1e-3, 1e-6), r = It((i / a) ** this.falloff, this.minWeight, this.maxWeight);
+    if (!Number.isFinite(r)) return t * this.minWeight;
+    const l = Ce.intersectsSphere(z) ? 1 : this.offScreenWeight;
+    return t * r * l;
   }
   /** Whether a weight moved enough to be worth a reallocation. */
-  isSignificant(i, e) {
-    return i === 0 || e === 0 ? i !== e : Math.abs(e - i) > this.weightDeadband * i;
+  isSignificant(s, e) {
+    return s === 0 || e === 0 ? s !== e : Math.abs(e - s) > this.weightDeadband * s;
   }
 }
-function It(o, i, e) {
-  return Math.min(e, Math.max(i, o));
+function It(o, s, e) {
+  return Math.min(e, Math.max(s, o));
 }
-function N(o, i) {
+function D(o, s) {
   if (!Number.isFinite(o) || o < 0)
-    throw new RangeError(`CameraBudgetGovernor ${i} must be a non-negative finite number.`);
+    throw new RangeError(`CameraBudgetGovernor ${s} must be a non-negative finite number.`);
   return o;
 }
-function U(o, i) {
+function U(o, s) {
   if (!Number.isFinite(o) || o <= 0)
-    throw new RangeError(`CameraBudgetGovernor ${i} must be a positive finite number.`);
+    throw new RangeError(`CameraBudgetGovernor ${s} must be a positive finite number.`);
   return o;
 }
 const Rt = 16, Mt = 1;
 class Ut {
-  constructor(i = {}) {
-    d(this, "entries", /* @__PURE__ */ new Set());
-    d(this, "maxGlobalInflight");
-    d(this, "perMeshFloor");
-    d(this, "inflightCount", 0);
-    d(this, "disposed", !1);
+  constructor(s = {}) {
+    u(this, "entries", /* @__PURE__ */ new Set());
+    u(this, "maxGlobalInflight");
+    u(this, "perMeshFloor");
+    u(this, "inflightCount", 0);
+    u(this, "disposed", !1);
     this.maxGlobalInflight = Math.max(
       1,
-      Math.floor(i.maxGlobalInflight ?? Rt)
-    ), this.perMeshFloor = Math.max(0, Math.floor(i.perMeshFloor ?? Mt));
+      Math.floor(s.maxGlobalInflight ?? Rt)
+    ), this.perMeshFloor = Math.max(0, Math.floor(s.perMeshFloor ?? Mt));
   }
   /** Total slots granted and not yet released. */
   get inflight() {
@@ -2639,16 +2673,16 @@ class Ut {
   get clientCount() {
     return this.entries.size;
   }
-  register(i) {
-    const e = { client: i, held: 0, demanding: !1, live: !0 };
+  register(s) {
+    const e = { client: s, held: 0, demanding: !1, live: !0 };
     return this.entries.add(e), e;
   }
   /**
    * Drops a mesh. Slots it still holds are released here: a disposing mesh
    * aborts its fetches, and those aborts land after the handle is gone.
    */
-  unregister(i) {
-    const e = i;
+  unregister(s) {
+    const e = s;
     this.entries.delete(e) && (e.live = !1, e.held > 0 && (this.inflightCount -= e.held, e.held = 0, this.wake()));
   }
   /**
@@ -2658,19 +2692,19 @@ class Ut {
    * mesh simply did not fetch this tick, and will be woken (or reschedule on
    * its own within the idle interval) to ask again.
    */
-  tryAcquire(i, e) {
-    const t = i;
+  tryAcquire(s, e) {
+    const t = s;
     if (this.disposed || !t.live) return !1;
-    const s = H(t.client.weight());
-    return e === "sweep" && s <= 0 ? (t.demanding = !1, !1) : this.inflightCount >= this.maxGlobalInflight || t.held >= this.shareFor(t, s) ? (t.demanding = !0, !1) : (t.held++, t.demanding = !1, this.inflightCount++, !0);
+    const i = H(t.client.weight());
+    return e === "sweep" && i <= 0 ? (t.demanding = !1, !1) : this.inflightCount >= this.maxGlobalInflight || t.held >= this.shareFor(t, i) ? (t.demanding = !0, !1) : (t.held++, t.demanding = !1, this.inflightCount++, !0);
   }
   /**
    * Returns a slot. Must be called exactly once for every granted acquire -
    * on success, on failure **and** on abort - or the pipe leaks capacity until
    * the scene is torn down.
    */
-  release(i) {
-    const e = i;
+  release(s) {
+    const e = s;
     e.held <= 0 || (e.held--, this.inflightCount--, this.wake());
   }
   /**
@@ -2683,8 +2717,8 @@ class Ut {
    */
   weightsChanged() {
     if (!this.disposed) {
-      for (const i of this.entries)
-        i.held > 0 && H(i.client.weight()) <= 0 && i.client.shedFetches("sweep");
+      for (const s of this.entries)
+        s.held > 0 && H(s.client.weight()) <= 0 && s.client.shedFetches("sweep");
       this.wake();
     }
   }
@@ -2695,8 +2729,8 @@ class Ut {
    */
   dispose() {
     this.disposed = !0;
-    for (const i of this.entries)
-      i.live = !1, i.held = 0, i.demanding = !1;
+    for (const s of this.entries)
+      s.live = !1, s.held = 0, s.demanding = !1;
     this.entries.clear(), this.inflightCount = 0;
   }
   /**
@@ -2716,47 +2750,47 @@ class Ut {
    * The denominator counts every mesh that plausibly wants the pipe - all
    * registered meshes except those both weightless and idle, plus the caller.
    */
-  shareFor(i, e) {
-    let t = 0, s = 0;
+  shareFor(s, e) {
+    let t = 0, i = 0;
     for (const l of this.entries) {
-      const c = l === i ? e : H(l.client.weight());
-      l !== i && c <= 0 && l.held === 0 && !l.demanding || (t++, s += c);
+      const c = l === s ? e : H(l.client.weight());
+      l !== s && c <= 0 && l.held === 0 && !l.demanding || (t++, i += c);
     }
     if (t <= 1) return this.maxGlobalInflight;
-    const n = s > 0 ? this.maxGlobalInflight * e / s : this.maxGlobalInflight / t, r = Math.max(1, this.perMeshFloor, Math.round(n)), a = Math.max(1, this.perMeshFloor) * (t - 1);
-    return Math.max(1, Math.min(r, this.maxGlobalInflight - a));
+    const n = i > 0 ? this.maxGlobalInflight * e / i : this.maxGlobalInflight / t, a = Math.max(1, this.perMeshFloor, Math.round(n)), r = Math.max(1, this.perMeshFloor) * (t - 1);
+    return Math.max(1, Math.min(a, this.maxGlobalInflight - r));
   }
   /** Pokes the heaviest mesh that was denied since its last grant. */
   wake() {
     if (this.disposed || this.inflightCount >= this.maxGlobalInflight) return;
-    let i = null, e = -1 / 0;
+    let s = null, e = -1 / 0;
     for (const t of this.entries) {
       if (!t.demanding) continue;
-      const s = H(t.client.weight());
-      s > e && (i = t, e = s);
+      const i = H(t.client.weight());
+      i > e && (s = t, e = i);
     }
-    i && (i.demanding = !1, i.client.onSlotAvailable());
+    s && (s.demanding = !1, s.client.onSlotAvailable());
   }
 }
 function H(o) {
   return Number.isFinite(o) && o > 0 ? o : 0;
 }
-const Ft = 32 * 1024 * 1024, Bt = 250, Et = 0.15;
+const Ft = 32 * 1024 * 1024, Bt = 250, Pt = 0.15;
 class Ht {
-  constructor(i) {
-    d(this, "entries", /* @__PURE__ */ new Set());
-    d(this, "perMeshFloorBytes");
-    d(this, "minIntervalMs");
-    d(this, "deadband");
-    d(this, "totalBytesValue");
-    d(this, "lastAllocationMs", Number.NEGATIVE_INFINITY);
-    d(this, "disposed", !1);
-    if (!Number.isFinite(i.totalBytes) || i.totalBytes <= 0)
+  constructor(s) {
+    u(this, "entries", /* @__PURE__ */ new Set());
+    u(this, "perMeshFloorBytes");
+    u(this, "minIntervalMs");
+    u(this, "deadband");
+    u(this, "totalBytesValue");
+    u(this, "lastAllocationMs", Number.NEGATIVE_INFINITY);
+    u(this, "disposed", !1);
+    if (!Number.isFinite(s.totalBytes) || s.totalBytes <= 0)
       throw new RangeError("Chunk cache totalBytes must be a positive finite number.");
-    this.totalBytesValue = Math.floor(i.totalBytes), this.perMeshFloorBytes = Math.max(
+    this.totalBytesValue = Math.floor(s.totalBytes), this.perMeshFloorBytes = Math.max(
       0,
-      Math.floor(i.perMeshFloorBytes ?? Ft)
-    ), this.minIntervalMs = Math.max(0, i.minIntervalMs ?? Bt), this.deadband = Math.max(0, i.deadband ?? Et);
+      Math.floor(s.perMeshFloorBytes ?? Ft)
+    ), this.minIntervalMs = Math.max(0, s.minIntervalMs ?? Bt), this.deadband = Math.max(0, s.deadband ?? Pt);
   }
   /** Bytes shared across every registered mesh. */
   get totalBytes() {
@@ -2766,10 +2800,10 @@ class Ht {
    * Resizes the scene envelope and re-splits immediately. For a host reacting
    * to a quality change or a device-memory signal.
    */
-  setTotalBytes(i) {
-    if (!Number.isFinite(i) || i <= 0)
+  setTotalBytes(s) {
+    if (!Number.isFinite(s) || s <= 0)
       throw new RangeError("Chunk cache totalBytes must be a positive finite number.");
-    const e = Math.floor(i);
+    const e = Math.floor(s);
     e !== this.totalBytesValue && (this.totalBytesValue = e, this.allocate());
   }
   /** Meshes currently registered. */
@@ -2780,18 +2814,18 @@ class Ht {
    * Adds a mesh and re-splits at once, so the caller can read its opening
    * allowance out of {@link allowanceFor} before posting worker init.
    */
-  register(i) {
-    const e = { client: i, allowance: 0, live: !0 };
+  register(s) {
+    const e = { client: s, allowance: 0, live: !0 };
     return this.entries.add(e), this.allocate({ force: !0, silentFor: e }), e;
   }
   /** Drops a mesh and hands its bytes back to the siblings. */
-  unregister(i) {
-    const e = i;
+  unregister(s) {
+    const e = s;
     this.entries.delete(e) && (e.live = !1, e.allowance = 0, this.allocate({ force: !0 }));
   }
   /** This mesh's current allowance in bytes, or 0 once unregistered. */
-  allowanceFor(i) {
-    const e = i;
+  allowanceFor(s) {
+    const e = s;
     return e.live ? e.allowance : 0;
   }
   /**
@@ -2801,8 +2835,8 @@ class Ht {
    *
    * Rate-limited and dead-banded; calling it every frame is the intended use.
    */
-  weightsChanged(i = Date.now()) {
-    this.disposed || i - this.lastAllocationMs < this.minIntervalMs || (this.lastAllocationMs = i, this.allocate());
+  weightsChanged(s = Date.now()) {
+    this.disposed || s - this.lastAllocationMs < this.minIntervalMs || (this.lastAllocationMs = s, this.allocate());
   }
   /**
    * Releases every registration. Meshes are not disposed - the budget is shared
@@ -2811,8 +2845,8 @@ class Ht {
    */
   dispose() {
     this.disposed = !0;
-    for (const i of this.entries)
-      i.live = !1, i.allowance = 0;
+    for (const s of this.entries)
+      s.live = !1, s.allowance = 0;
     this.entries.clear();
   }
   /**
@@ -2826,34 +2860,34 @@ class Ht {
    * silently overcommitting, because a budget that can be exceeded by
    * registering more meshes is the bug this class exists to fix.
    */
-  allocate(i = {}) {
+  allocate(s = {}) {
     if (this.disposed) return;
     const e = [...this.entries];
     if (e.length === 0) return;
-    const t = this.totalBytesValue, s = Math.min(this.perMeshFloorBytes, Math.floor(t / e.length)), n = /* @__PURE__ */ new Map(), r = new Set(e);
-    let a = t;
-    for (let l = 0; l <= e.length && r.size > 0; l++) {
-      const c = Math.max(0, a - s * r.size);
+    const t = this.totalBytesValue, i = Math.min(this.perMeshFloorBytes, Math.floor(t / e.length)), n = /* @__PURE__ */ new Map(), a = new Set(e);
+    let r = t;
+    for (let l = 0; l <= e.length && a.size > 0; l++) {
+      const c = Math.max(0, r - i * a.size);
       let h = 0;
-      for (const u of r) h += Te(u.client.weight());
+      for (const d of a) h += Te(d.client.weight());
       const f = [];
-      for (const u of r) {
-        const g = Te(u.client.weight()), v = h > 0 ? c * g / h : c / r.size, m = kt(u.client.ceilingBytes), b = Math.floor(s + v);
-        b >= m ? (n.set(u, m), f.push(u)) : n.set(u, b);
+      for (const d of a) {
+        const g = Te(d.client.weight()), v = h > 0 ? c * g / h : c / a.size, m = kt(d.client.ceilingBytes), b = Math.floor(i + v);
+        b >= m ? (n.set(d, m), f.push(d)) : n.set(d, b);
       }
       if (f.length === 0) break;
-      for (const u of f)
-        r.delete(u), a -= n.get(u) ?? 0;
-      a = Math.max(0, a);
+      for (const d of f)
+        a.delete(d), r -= n.get(d) ?? 0;
+      r = Math.max(0, r);
     }
     for (const l of e) {
       const c = n.get(l) ?? 0, h = l.allowance;
-      l.allowance = c, l !== i.silentFor && (!i.force && !this.movedEnough(h, c) || h !== c && l.client.onAllowanceChanged(c));
+      l.allowance = c, l !== s.silentFor && (!s.force && !this.movedEnough(h, c) || h !== c && l.client.onAllowanceChanged(c));
     }
   }
   /** Suppresses reposts for changes too small to alter any mesh's behaviour. */
-  movedEnough(i, e) {
-    return i === e ? !1 : i === 0 || e === 0 ? !0 : Math.abs(e - i) / i >= this.deadband;
+  movedEnough(s, e) {
+    return s === e ? !1 : s === 0 || e === 0 ? !0 : Math.abs(e - s) / s >= this.deadband;
   }
 }
 function Te(o) {
@@ -2864,14 +2898,14 @@ function kt(o) {
 }
 export {
   Tt as BudgetGovernor,
-  Ot as CameraBudgetGovernor,
+  zt as CameraBudgetGovernor,
   Ht as ChunkCacheBudget,
   Ut as ChunkFetchScheduler,
   q as SplatLoadError,
   Y as StreamedSplatMesh,
   ot as createLocalDataset,
   nt as httpDatasetSource,
-  G as isAbortError,
+  N as isAbortError,
   Be as resolveCpuCacheBytes
 };
 //# sourceMappingURL=streaming.js.map