@voluma/vlam 0.3.2 → 0.3.4

package/dist/streaming.js

@@ -1,111 +1,111 @@
-var Me = Object.defineProperty;
-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);
+var Fe = Object.defineProperty;
+var Me = (l, i, e) => i in l ? Fe(l, i, { enumerable: !0, configurable: !0, writable: !0, value: e }) : l[i] = e;
+var d = (l, i, e) => Me(l, typeof i != "symbol" ? i + "" : i, 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 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 N, a as _ } from "./loading-wLo8vRbA.js";
+import { L as We, r as C } from "./lod-scheduler-ChoZyEeq.js";
+import { S as q, t as ee, r as Ae, i as D, 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 { s as Te } from "./sh-pack-D5wAe5gg.js";
 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((s) => ({
-    adds: [s],
+import { r as Ge, M as Ne, a as ne, i as j } from "./splat-mesh-types-BZIko-_9.js";
+const De = 32e3;
+function _e(l) {
+  return l.map((i) => ({
+    adds: [i],
     removes: [],
-    leafStart: s.leafStart,
-    leafEnd: s.leafEnd,
-    addCount: s.count
-  })).sort((s, e) => s.leafStart - e.leafStart);
+    leafStart: i.leafStart,
+    leafEnd: i.leafEnd,
+    addCount: i.count
+  })).sort((i, e) => i.leafStart - e.leafStart);
 }
-function Oe(o, s) {
-  const e = [...o, ...s.map(([, n]) => n.run)];
+function Oe(l, i) {
+  const e = [...l, ...i.map(([, n]) => n.run)];
   if (e.length > 0 && e.every((n) => n.coverageGroup !== void 0)) {
-    const n = /* @__PURE__ */ new Map(), a = (l) => {
-      let c = n.get(l);
-      return c || (c = { adds: [], removes: [] }, n.set(l, c)), c;
+    const n = /* @__PURE__ */ new Map(), a = (r) => {
+      let c = n.get(r);
+      return c || (c = { adds: [], removes: [] }, n.set(r, c)), c;
     };
-    for (const l of o)
-      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 = (d, g) => `${d}:${g}`, f = (d, g) => {
-        const v = h(d, g);
+    for (const r of l)
+      a(r.coverageGroup).adds.push(r);
+    for (const r of i)
+      a(r[1].run.coverageGroup).removes.push(r);
+    const o = [];
+    for (const r of n.values()) {
+      const c = /* @__PURE__ */ new Map(), u = (h, g) => `${h}:${g}`, f = (h, g) => {
+        const v = u(h, g);
         let m = c.get(v);
-        return m || (m = { adds: [], removes: [], leafStart: d, leafEnd: g, addCount: 0 }, c.set(v, m)), m;
+        return m || (m = { adds: [], removes: [], leafStart: h, leafEnd: g, addCount: 0 }, c.set(v, m)), m;
       };
-      for (const d of l.adds) {
-        const g = f(d.leafStart, d.leafEnd);
-        g.adds.push(d), g.addCount += d.count;
+      for (const h of r.adds) {
+        const g = f(h.leafStart, h.leafEnd);
+        g.adds.push(h), g.addCount += h.count;
       }
-      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);
+      for (const h of r.removes) {
+        const g = h[1].run, v = f(g.leafStart, g.leafEnd);
+        v.removes.push(h), v.leafStart = Math.min(v.leafStart, g.leafStart), v.leafEnd = Math.max(v.leafEnd, g.leafEnd);
       }
-      r.push(...c.values());
+      o.push(...c.values());
     }
-    return r.sort((l, c) => l.leafStart - c.leafStart);
+    return o.sort((r, c) => r.leafStart - c.leafStart);
   }
   const t = [
-    ...o.map((n) => ({
+    ...l.map((n) => ({
       start: n.leafStart,
       end: n.leafEnd,
       add: n,
       remove: void 0
     })),
-    ...s.map((n) => ({
+    ...i.map((n) => ({
       start: n[1].run.leafStart,
       end: n[1].run.leafEnd,
       add: void 0,
       remove: n
     }))
-  ].sort((n, a) => n.start - a.start || a.end - n.end), i = [];
+  ].sort((n, a) => n.start - a.start || a.end - n.end), s = [];
   for (const n of t) {
-    const a = i[i.length - 1];
-    (!a || n.start >= a.leafEnd) && i.push({
+    const a = s[s.length - 1];
+    (!a || n.start >= a.leafEnd) && s.push({
       adds: [],
       removes: [],
       leafStart: n.start,
       leafEnd: n.end,
       addCount: 0
     });
-    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);
+    const o = s[s.length - 1];
+    o.leafEnd = Math.max(o.leafEnd, n.end), n.add && (o.adds.push(n.add), o.addCount += n.add.count), n.remove && o.removes.push(n.remove);
   }
-  return i;
+  return s;
 }
-function ae(o) {
-  if (o.adds.length === 0) return 1e3;
-  const s = -Math.max(...o.adds.map((e) => e.level));
-  return o.removes.length === 0 ? -1e3 + s : s;
+function ae(l) {
+  if (l.adds.length === 0) return 1e3;
+  const i = -Math.max(...l.adds.map((e) => e.level));
+  return l.removes.length === 0 ? -1e3 + i : i;
 }
-function ze(o) {
-  return o.length > 0 && o.every(
-    (s) => [...s.adds, ...s.removes.map(([, e]) => e.run)].every(
+function ze(l) {
+  return l.length > 0 && l.every(
+    (i) => [...i.adds, ...i.removes.map(([, e]) => e.run)].every(
       (e) => e.coverageGroup !== void 0
     )
   );
 }
-function Ue(o, s) {
+function Ue(l, i) {
   const e = (n) => {
-    const a = [...n.adds, ...n.removes.map(([, r]) => r.run)];
+    const a = [...n.adds, ...n.removes.map(([, o]) => o.run)];
     return {
       removeOnly: n.adds.length === 0 ? 1 : 0,
-      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))
+      view: a.some((o) => o.inView !== !1) ? 0 : 1,
+      finest: n.adds.some((o) => o.level === 0) ? 0 : 1,
+      screen: Math.min(...a.map((o) => o.screenImportance ?? Number.POSITIVE_INFINITY)),
+      distance: Math.min(...a.map((o) => o.distance ?? Number.POSITIVE_INFINITY))
     };
-  }, 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;
+  }, t = e(l), s = e(i);
+  return t.removeOnly - s.removeOnly || t.view - s.view || t.finest - s.finest || t.screen - s.screen || t.distance - s.distance || l.leafStart - i.leafStart;
 }
-function re(o) {
-  switch (o) {
+function re(l) {
+  switch (l) {
     case "environment":
       return -1;
     case "finest-target":
@@ -118,19 +118,19 @@ function re(o) {
       return 3;
   }
 }
-function He(o) {
-  return o === "background" ? "base" : "priority";
+function He(l) {
+  return l === "background" ? "base" : "priority";
 }
-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 N(l, i) {
+  return l.coverageGroup < 0 ? `file:${i}` : l.phase === "finest-target" ? `cell:${l.coverageGroup}` : `slice:${l.coverageGroup}:${l.leafStart}:${l.leafEnd}`;
 }
-function $e(o, s = 10, e = !1) {
-  const t = te(s), i = /* @__PURE__ */ new Map();
-  for (const [n, a] of o) {
+function $e(l, i = 10, e = !1) {
+  const t = te(i), s = /* @__PURE__ */ new Map();
+  for (const [n, a] of l) {
     if (a.phase === "environment") continue;
-    const r = G(a, n), l = i.get(r);
-    if (!l) {
-      i.set(r, {
+    const o = N(a, n), r = s.get(o);
+    if (!r) {
+      s.set(o, {
         distance: a.distance,
         count: 1,
         inView: a.inView,
@@ -139,55 +139,55 @@ function $e(o, s = 10, e = !1) {
       });
       continue;
     }
-    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++;
+    a.distance < r.distance && (r.distance = a.distance), a.inView && (r.inView = !0), a.screenImportance < r.screenImportance && (r.screenImportance = a.screenImportance), a.phase === "finest-target" && (r.finest = !0), r.count++;
   }
-  for (const [n, a] of o) {
+  for (const [n, a] of l) {
     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 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";
-    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;
+    const o = N(a, n), r = s.get(o);
+    if (!r) continue;
+    const c = r.inView ? 0 : r.distance <= t ? 1 : 2, u = c === 0 || c === 1 && e ? "priority" : "base";
+    a.groupDistance = r.distance, a.groupPending = r.count, a.groupInView = r.inView, a.groupScreenImportance = r.screenImportance, a.groupFinest = r.finest, a.groupId = o, a.groupClass = c, a.kind = u;
   }
 }
-function te(o, s = 2) {
-  return o;
+function te(l, i = 2) {
+  return l;
 }
-function Ye(o) {
-  return o.adds.some((s) => s.level === 0);
+function Ye(l) {
+  return l.adds.some((i) => i.level === 0);
 }
-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(s) ? "background" : "target";
+function qe(l, i, e = 2) {
+  if (l.level === 0) return "finest-target";
+  const t = l.distance ?? Number.POSITIVE_INFINITY;
+  return l.inView === !1 && t > te(i) ? "background" : "target";
 }
-function je(o, s, e = 2) {
-  const t = o.distance ?? Number.POSITIVE_INFINITY;
-  return o.inView === !1 && t > te(s) ? "background" : "coverage";
+function je(l, i, e = 2) {
+  const t = l.distance ?? Number.POSITIVE_INFINITY;
+  return l.inView === !1 && t > te(i) ? "background" : "coverage";
 }
-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 = G(
-      { phase: e, coverageGroup: r, leafStart: t.leafStart, leafEnd: t.leafEnd },
-      s
+function oe(l, i, e, t) {
+  const s = t.distance ?? Number.POSITIVE_INFINITY, n = t.level, a = t.inView !== !1, o = t.coverageGroup ?? -1, r = t.screenImportance ?? Number.POSITIVE_INFINITY, c = He(e), u = l.get(i);
+  if (!u) {
+    const v = N(
+      { phase: e, coverageGroup: o, leafStart: t.leafStart, leafEnd: t.leafEnd },
+      i
     );
-    o.set(s, {
+    l.set(i, {
       kind: c,
       phase: e,
-      distance: i,
+      distance: s,
       level: n,
       inView: a,
-      coverageGroup: r,
+      coverageGroup: o,
       leafStart: t.leafStart,
       leafEnd: t.leafEnd,
-      screenImportance: l,
-      groupDistance: i,
+      screenImportance: r,
+      groupDistance: s,
       groupPending: 1,
       groupInView: a,
-      groupScreenImportance: l,
+      groupScreenImportance: r,
       groupFinest: e === "finest-target",
       groupId: v,
       // Provisional; finalized in stampClassicFetchGroups().
@@ -195,41 +195,41 @@ function oe(o, s, e, t) {
     });
     return;
   }
-  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, {
+  const f = re(e) < re(u.phase), h = e === u.phase && (s < u.distance || s === u.distance && n < u.level), g = e === u.phase && s === u.distance && n === u.level && a && !u.inView;
+  (f || h || g) && l.set(i, {
     kind: c,
     phase: e,
-    distance: i,
+    distance: s,
     level: n,
-    inView: a || h.inView,
-    coverageGroup: r >= 0 ? r : h.coverageGroup,
+    inView: a || u.inView,
+    coverageGroup: o >= 0 ? o : u.coverageGroup,
     leafStart: t.leafStart,
     leafEnd: t.leafEnd,
-    screenImportance: l,
-    groupDistance: Math.min(i, h.groupDistance),
-    groupPending: h.groupPending,
-    groupInView: a || h.groupInView,
-    groupScreenImportance: Math.min(l, h.groupScreenImportance),
-    groupFinest: e === "finest-target" || h.groupFinest,
-    groupId: h.groupId,
-    groupClass: h.groupClass
+    screenImportance: r,
+    groupDistance: Math.min(s, u.groupDistance),
+    groupPending: u.groupPending,
+    groupInView: a || u.groupInView,
+    groupScreenImportance: Math.min(r, u.groupScreenImportance),
+    groupFinest: e === "finest-target" || u.groupFinest,
+    groupId: u.groupId,
+    groupClass: u.groupClass
   });
 }
-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 X(l, i, e, t) {
+  const s = l.groupDistance ?? l.distance, n = i.groupDistance ?? i.distance, a = l.groupPending ?? 1, o = i.groupPending ?? 1, r = l.groupId ?? N(l, e), c = i.groupId ?? N(i, t), u = l.groupClass ?? (l.inView ? 0 : 2), f = i.groupClass ?? (i.inView ? 0 : 2), h = l.groupScreenImportance ?? l.screenImportance, g = i.groupScreenImportance ?? i.screenImportance, v = l.groupFinest ? 0 : 1, m = i.groupFinest ? 0 : 1, b = (y) => y === "coverage" ? 0 : y === "background" ? 2 : 1, I = l.phase === "environment" ? 0 : 1, T = i.phase === "environment" ? 0 : 1;
+  return I - T || u - f || v - m || h - g || s - n || o - a || (r < c ? -1 : r > c ? 1 : 0) || b(l.phase) - b(i.phase) || l.level - i.level || e - t;
 }
-function K(o, s, e) {
-  if (s < 0 || e < 0 || s + e > o.count)
+function K(l, i, e) {
+  if (i < 0 || e < 0 || i + e > l.count)
     throw new Error(
-      `Splat range [${s}, ${s + e}) exceeds its chunk's ${o.count} splats; the manifest and chunk data disagree.`
+      `Splat range [${i}, ${i + e}) exceeds its chunk's ${l.count} splats; the manifest and chunk data disagree.`
     );
-  const t = o.shPacked;
+  const t = l.shPacked;
   return {
     count: e,
-    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),
+    positions: l.positions.subarray(i * 3, (i + e) * 3),
+    colors: l.colors.subarray(i * 4, (i + e) * 4),
+    covariances: l.covariances.subarray(i * 6, (i + 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,259 +237,259 @@ function K(o, s, e) {
       shPacked: {
         ...t,
         packed: t.packed.subarray(
-          s * le(t.bands),
-          (s + e) * le(t.bands)
+          i * le(t.bands),
+          (i + 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(s, s + e) } : {}
+    ...l.frontierParent ? { frontierParent: l.frontierParent.subarray(i, i + e) } : {}
   };
 }
-function le(o) {
-  return o === 1 ? 3 : o === 2 ? 8 : 15;
+function le(l) {
+  return l === 1 ? 3 : l === 2 ? 8 : 15;
 }
-function Xe(o) {
-  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
+function Xe(l) {
+  var i;
+  return l.positions.byteLength + l.colors.byteLength + l.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.
-  (((s = o.shPacked) == null ? void 0 : s.packed.byteLength) ?? 0);
+  (((i = l.shPacked) == null ? void 0 : i.packed.byteLength) ?? 0);
 }
-function Ke(o) {
-  const s = o.reason;
-  return s instanceof Error ? s : new DOMException("Aborted", "AbortError");
+function Ke(l) {
+  const i = l.reason;
+  return i instanceof Error ? i : new DOMException("Aborted", "AbortError");
 }
-function Qe(o) {
-  const s = o ?? Ne;
-  if (!Number.isInteger(s) || s <= 0)
+function Qe(l) {
+  const i = l ?? De;
+  if (!Number.isInteger(i) || i <= 0)
     throw new RangeError("StreamedSplatMesh maxSplatsPerSwap must be a positive integer.");
-  return s;
+  return i;
 }
-function ce(o) {
-  const s = o ?? 1;
-  if (!Number.isFinite(s) || s <= 0)
+function ce(l) {
+  const i = l ?? 1;
+  if (!Number.isFinite(i) || i <= 0)
     throw new RangeError("StreamedSplatMesh lodScale must be a positive finite number.");
-  return s;
+  return i;
 }
 function Je() {
   return Be();
 }
-function Ze(o, s) {
-  const e = o;
+function Ze(l, i) {
+  const e = l;
   if (typeof e != "object" || e === null)
     throw new Error("Streamed SOG manifest is not a JSON object.");
   if (e.version !== 1)
     throw new Error(`Unsupported Streamed SOG manifest version: ${e.version} (expected 1).`);
-  if (!Array.isArray(e.filenames) || e.filenames.some((l) => typeof l != "string"))
+  if (!Array.isArray(e.filenames) || e.filenames.some((r) => typeof r != "string"))
     throw new Error('Streamed SOG manifest "filenames" must be an array of strings.');
-  if (!Array.isArray(e.counts) || e.counts.some((l) => !Number.isSafeInteger(l) || l < 0))
+  if (!Array.isArray(e.counts) || e.counts.some((r) => !Number.isSafeInteger(r) || r < 0))
     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$/, "/")), 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)
+  const t = e.filenames.map((r) => r.replace(/\/?meta\.json$/, "/")), s = t.map(
+    (r) => i.resolve(r) ?? `${i.manifestUrl}#${r}`
+  ), n = [], a = e.lodLevels, o = [e.tree];
+  for (; o.length > 0; ) {
+    const r = o.pop();
+    if (typeof r != "object" || r === null)
       throw new Error("Streamed SOG manifest tree contains a malformed node.");
-    if (l.children) {
-      if (!Array.isArray(l.children) || l.children.length !== 2)
+    if (r.children) {
+      if (!Array.isArray(r.children) || r.children.length !== 2)
         throw new Error("Streamed SOG manifest tree node must have exactly two children.");
-      r.push(l.children[1], l.children[0]);
+      o.push(r.children[1], r.children[0]);
       continue;
     }
     const c = new Array(a).fill(
       void 0
     );
-    for (const [h, f] of Object.entries(l.lods ?? {})) {
-      const d = Number(h);
-      d >= 0 && d < a && (et(f, e.filenames.length), c[d] = f);
+    for (const [u, f] of Object.entries(r.lods ?? {})) {
+      const h = Number(u);
+      h >= 0 && h < a && (et(f, e.filenames.length), c[h] = f);
     }
-    n.push({ bounds: he(l.bound), lods: c });
+    n.push({ bounds: he(r.bound), lods: c });
   }
   return {
     leaves: n,
-    chunkUrls: i,
+    chunkUrls: s,
     chunkDirectories: t,
     counts: e.counts,
     lodLevels: a,
     bounds: he(e.tree.bound)
   };
 }
-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)
+function et(l, i) {
+  if (typeof l != "object" || l === null || !Number.isSafeInteger(l.file) || l.file < 0 || l.file >= i || !Number.isSafeInteger(l.offset) || l.offset < 0 || !Number.isSafeInteger(l.count) || l.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}).`
+      `Streamed SOG manifest leaf declares an invalid LOD range (file ${l == null ? void 0 : l.file}, offset ${l == null ? void 0 : l.offset}, count ${l == null ? void 0 : l.count}).`
     );
 }
-function he(o) {
+function he(l) {
   return new w.Box3(
-    new w.Vector3(o.min[0], o.min[1], o.min[2]),
-    new w.Vector3(o.max[0], o.max[1], o.max[2])
+    new w.Vector3(l.min[0], l.min[1], l.min[2]),
+    new w.Vector3(l.max[0], l.max[1], l.max[2])
   );
 }
-function tt(o, s, e, t = 0) {
-  const i = Ze(o, s), n = t >= 1 ? t : void 0, a = i.chunkUrls.map((r, l) => {
+function tt(l, i, e, t = 0) {
+  const s = Ze(l, i), n = t >= 1 ? t : void 0, a = s.chunkUrls.map((o, r) => {
     var f;
-    const c = (f = i.chunkDirectories) == null ? void 0 : f[l], h = c ? s.directoryFiles(c) : null;
-    if (!(!h && !n))
+    const c = (f = s.chunkDirectories) == null ? void 0 : f[r], u = c ? i.directoryFiles(c) : null;
+    if (!(!u && !n))
       return {
         format: "sog",
-        ...h ? { files: h } : {},
+        ...u ? { files: u } : {},
         ...n ? { sog: { packShBands: n } } : {}
       };
   });
   return {
-    source: new We(i, e),
-    chunkUrls: i.chunkUrls,
+    source: new We(s, e),
+    chunkUrls: s.chunkUrls,
     ...a.some(Boolean) ? { chunkOptions: a } : {},
     ...n ? { shBands: n } : {},
     chunkKind: "directory",
     // Streamed SOG chunks are unbundled directories
-    bounds: i.bounds,
-    pinnedFiles: it(i),
-    maxResidentSplats: i.counts[0] ?? e.budget,
-    minimumCoverageSplats: st(i)
+    bounds: s.bounds,
+    pinnedFiles: it(s),
+    maxResidentSplats: s.counts[0] ?? e.budget,
+    minimumCoverageSplats: st(s)
   };
 }
-function st(o) {
-  let s = 0;
-  for (const e of o.leaves)
+function st(l) {
+  let i = 0;
+  for (const e of l.leaves)
     for (let t = e.lods.length - 1; t >= 0; t--) {
-      const i = e.lods[t];
-      if (i) {
-        s += i.count;
+      const s = e.lods[t];
+      if (s) {
+        i += s.count;
         break;
       }
     }
-  return Math.max(1, s);
+  return Math.max(1, i);
 }
-function it(o) {
-  const s = /* @__PURE__ */ new Set();
-  for (const e of o.leaves)
+function it(l) {
+  const i = /* @__PURE__ */ new Set();
+  for (const e of l.leaves)
     for (let t = e.lods.length - 1; t >= 0; t--) {
-      const i = e.lods[t];
-      if (i) {
-        s.add(i.file);
+      const s = e.lods[t];
+      if (s) {
+        i.add(s.file);
         break;
       }
     }
-  return s;
+  return i;
 }
-function nt(o, s) {
+function nt(l, i) {
   return {
-    manifestUrl: o,
-    resolve: (e) => new URL(e, o).href,
-    size: (e) => at(new URL(e, o).href, s),
+    manifestUrl: l,
+    resolve: (e) => new URL(e, l).href,
+    size: (e) => at(new URL(e, l).href, i),
     directoryFiles: () => null,
     dispose: () => {
     }
   };
 }
-async function at(o, s) {
+async function at(l, i) {
   var e;
   try {
-    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));
+    const t = await fetch(l, { ...ee(i), method: "HEAD" });
+    if (await ue(t), t.ok) {
+      const s = t.headers.get("content-length");
+      if (s !== null) return de(Number(s));
     } else if (t.status === 404)
       return null;
   } catch {
   }
   try {
-    const t = await fetch(o, {
-      ...ee(s),
-      headers: { ...(s == null ? void 0 : s.headers) ?? {}, Range: "bytes=0-0" }
+    const t = await fetch(l, {
+      ...ee(i),
+      headers: { ...(i == null ? void 0 : i.headers) ?? {}, Range: "bytes=0-0" }
     });
-    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));
+    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));
   } catch {
     return null;
   }
 }
-async function de(o) {
-  var s;
+async function ue(l) {
+  var i;
   try {
-    await ((s = o.body) == null ? void 0 : s.cancel());
+    await ((i = l.body) == null ? void 0 : i.cancel());
   } catch {
   }
 }
-function ue(o) {
-  return Number.isSafeInteger(o) && o >= 0 ? o : null;
+function de(l) {
+  return Number.isSafeInteger(l) && l >= 0 ? l : null;
 }
 const rt = [
-  { test: (o) => o.endsWith(".lcc2"), format: "lcc2" },
-  { test: (o) => o.endsWith(".lcc"), format: "lcc" },
+  { test: (l) => l.endsWith(".lcc2"), format: "lcc2" },
+  { test: (l) => l.endsWith(".lcc"), format: "lcc" },
   // The `.rad` header of a `--rad-chunked` set; `.radc` chunk files are not
   // manifests (they end in `.radc`, so `endsWith('.rad')` excludes them).
-  { test: (o) => o.endsWith(".rad"), format: "rad" },
-  { test: (o) => o === "lod-meta.json", format: "streamed-sog" }
+  { test: (l) => l.endsWith(".rad"), format: "rad" },
+  { test: (l) => l === "lod-meta.json", format: "streamed-sog" }
 ];
-function ot(o) {
-  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 });
+function ot(l) {
+  const i = [];
+  for (const o of l.keys()) {
+    const r = $(o).toLowerCase(), c = rt.find((u) => u.test(r));
+    c && Re(o) === lt(l, c) && i.push({ path: o, format: c.format });
   }
-  if (s.length === 0)
+  if (i.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 (s.length > 1) {
-    const r = s.map((l) => $(l.path)).join(", ");
+  if (i.length > 1) {
+    const o = i.map((r) => $(r.path)).join(", ");
     throw new q(
-      `That folder holds more than one scene manifest (${r}) - drop one scene at a time.`,
+      `That folder holds more than one scene manifest (${o}) - drop one scene at a time.`,
       { phase: "manifest", url: "local-folder", retryable: !1 }
     );
   }
-  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(r);
+  const e = i[0], t = e.path.includes("/") ? e.path.slice(0, e.path.lastIndexOf("/") + 1) : "", s = /* @__PURE__ */ new Map(), n = (o) => {
+    const r = s.get(o);
+    if (r !== void 0) return r;
+    const c = l.get(o);
     if (!c) return null;
-    const h = URL.createObjectURL(c);
-    return i.set(r, h), h;
+    const u = URL.createObjectURL(c);
+    return s.set(o, u), u;
   };
   return { source: {
     manifestUrl: n(e.path),
-    resolve: (r) => n(t + Q(r)),
-    size: (r) => {
-      var l;
-      return Promise.resolve(((l = o.get(t + Q(r))) == null ? void 0 : l.size) ?? null);
+    resolve: (o) => n(t + Q(o)),
+    size: (o) => {
+      var r;
+      return Promise.resolve(((r = l.get(t + Q(o))) == null ? void 0 : r.size) ?? null);
     },
-    directoryFiles: (r) => {
-      const l = t + Q(r).replace(/\/?$/, "/"), c = {};
-      for (const h of o.keys()) {
-        if (!h.startsWith(l)) continue;
-        const f = n(h);
-        f && (c[h.slice(l.length)] = f);
+    directoryFiles: (o) => {
+      const r = t + Q(o).replace(/\/?$/, "/"), c = {};
+      for (const u of l.keys()) {
+        if (!u.startsWith(r)) continue;
+        const f = n(u);
+        f && (c[u.slice(r.length)] = f);
       }
       return Object.keys(c).length > 0 ? c : null;
     },
     dispose: () => {
-      for (const r of i.values()) URL.revokeObjectURL(r);
-      i.clear();
+      for (const o of s.values()) URL.revokeObjectURL(o);
+      s.clear();
     }
   }, format: e.format, name: $(e.path) };
 }
-function Q(o) {
-  return o.replace(/^\.?\//, "");
+function Q(l) {
+  return l.replace(/^\.?\//, "");
 }
-function $(o) {
-  return o.slice(o.lastIndexOf("/") + 1);
+function $(l) {
+  return l.slice(l.lastIndexOf("/") + 1);
 }
-function Re(o) {
-  return o.split("/").length - 1;
+function Re(l) {
+  return l.split("/").length - 1;
 }
-function lt(o, s) {
+function lt(l, i) {
   let e = 1 / 0;
-  for (const t of o.keys())
-    s.test($(t).toLowerCase()) && (e = Math.min(e, Re(t)));
+  for (const t of l.keys())
+    i.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, 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 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;
+}, B = 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;
+function bt(l) {
+  const i = 52 + (l.shBands ? 16 * Math.ceil(Te(l.shBands) / 4) : 0), t = (l.chunkSize === void 0 ? void 0 : l.chunkSize * l.chunkUrls.length) ?? l.contentSplatCount ?? l.maxResidentSplats;
+  return Math.max(1, t) * i;
 }
 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());
+  constructor(e, t, s, n, a, o = !1) {
+    var h, g, v;
+    super({ capacity: s }, n);
+    d(this, "scene");
+    d(this, "loader", new Ve());
     /**
      * Cap the *classic* (non-page-table) chunk cache evicts against.
      *
@@ -515,67 +515,67 @@ class Y extends Ee {
      * moves; without a budget it stays at the value `options.cpuCacheBytes` or the
      * device default set at construction.
      */
-    u(this, "cpuCacheBytes");
-    u(this, "budgetValue");
-    u(this, "maximumBudget");
+    d(this, "cpuCacheBytes");
+    d(this, "budgetValue");
+    d(this, "maximumBudget");
     /** Spark's per-mesh `lodScale`; divides the page-table cut limit. */
-    u(this, "lodScaleValue");
+    d(this, "lodScaleValue");
     /** Set once the governed budget has been reported as exceeding an explicit
      * `foveationDrawBudget`, so the warning is issued at most once. */
-    u(this, "warnedDrawTargetCap", !1);
-    u(this, "stagedSwapsEnabled");
+    d(this, "warnedDrawTargetCap", !1);
+    d(this, "stagedSwapsEnabled");
     /** Classic LCC must keep old cell coverage while a replacement is pending. */
-    u(this, "neverRetireCoverageEarly");
-    u(this, "appendCap");
-    u(this, "onPerformanceEvent");
-    u(this, "compactionCount", 0);
-    u(this, "cache", /* @__PURE__ */ new Map());
+    d(this, "neverRetireCoverageEarly");
+    d(this, "appendCap");
+    d(this, "onPerformanceEvent");
+    d(this, "compactionCount", 0);
+    d(this, "cache", /* @__PURE__ */ new Map());
     /** Running byte total of {@link cache}; maintained by {@link cacheChunk}, eviction and dispose. */
-    u(this, "cacheBytesTotal", 0);
+    d(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. */
-    u(this, "fetching", /* @__PURE__ */ new Map());
+    d(this, "fetching", /* @__PURE__ */ new Map());
     /** This mesh's camera-projected share of the scene's fetch bandwidth. */
-    u(this, "fetchWeight");
+    d(this, "fetchWeight");
     /** Scene-wide fetch arbitration, when the host shares one; see `requestChunk`. */
-    u(this, "fetchScheduler");
-    u(this, "fetchHandle");
+    d(this, "fetchScheduler");
+    d(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.
      */
-    u(this, "localSource");
+    d(this, "localSource");
     /** Scene-wide chunk-cache ceiling, when the host shares one. */
-    u(this, "cacheBudget");
-    u(this, "cacheBudgetHandle");
+    d(this, "cacheBudget");
+    d(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.
      */
-    u(this, "cacheLimitBytes", 0);
-    u(this, "resident", /* @__PURE__ */ new Map());
+    d(this, "cacheLimitBytes", 0);
+    d(this, "resident", /* @__PURE__ */ new Map());
     /** Replacement runs hidden while their pool data is uploaded in bounded segments. */
-    u(this, "staged", /* @__PURE__ */ new Map());
+    d(this, "staged", /* @__PURE__ */ new Map());
     /** Files awaiting a backoff retry after a transient fetch/decode error. */
-    u(this, "retrying", /* @__PURE__ */ new Map());
+    d(this, "retrying", /* @__PURE__ */ new Map());
     /** Files given up on after {@link MAX_CHUNK_ATTEMPTS} failures. */
-    u(this, "failedFiles", /* @__PURE__ */ new Set());
+    d(this, "failedFiles", /* @__PURE__ */ new Set());
     /**
      * When true, each resident run writes its LOD `level` into the `lodLevel`
      * float channel for false-color debug modifiers.
      */
-    u(this, "lodLevelDebug", !1);
-    u(this, "lodLevelChannelReady", !1);
-    u(this, "lodLevelScratch");
+    d(this, "lodLevelDebug", !1);
+    d(this, "lodLevelChannelReady", !1);
+    d(this, "lodLevelScratch");
     /** Desired-but-not-resident files this tick; protected from cache eviction. */
-    u(this, "neededFiles", /* @__PURE__ */ new Set());
+    d(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. */
-    u(this, "frontierWorker");
+    d(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 Ee {
      * (Spark's pager does the same thing one level down, binding fixed pages to
      * `(source, chunk)` pairs.)
      */
-    u(this, "slabPages", []);
+    d(this, "slabPages", []);
     /** Most slots the slab may ever hold - the construction capacity. */
-    u(this, "slabCeiling", 0);
+    d(this, "slabCeiling", 0);
     /** Slot count the worker's pager was last told about. */
-    u(this, "pagerSlots", 0);
+    d(this, "pagerSlots", 0);
     /** Consecutive ticks the wave gate has held retirements back. */
-    u(this, "retireHeldTicks", 0);
+    d(this, "retireHeldTicks", 0);
     /** Backing store for {@link planTimings}. */
-    u(this, "planTimingsValue", {
+    d(this, "planTimingsValue", {
       applyMs: 0,
       worstApplyMs: 0,
       writeMs: 0,
@@ -610,7 +610,7 @@ class Y extends Ee {
      * they answer is about a *steady state* - "this keeps streaming after the view
      * settled" - which a per-frame or windowed number cannot express.
      */
-    u(this, "fetchCountsValue", {
+    d(this, "fetchCountsValue", {
       priority: 0,
       base: 0,
       sweep: 0,
@@ -626,55 +626,55 @@ class Y extends Ee {
      * 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.
      */
-    u(this, "frontierBandBase", null);
+    d(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.
      */
-    u(this, "slabPageSplats", ge);
+    d(this, "slabPageSplats", ge);
     /** Target drawn-splat count for the page-table frontier; see the constructor. */
-    u(this, "pageTableDrawBudget", 0);
+    d(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`). */
-    u(this, "pageTableDrawTarget", 0);
+    d(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. */
-    u(this, "pageTableDrawTargetExplicit", !1);
+    d(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. */
-    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);
+    d(this, "pageTableDrawn", 0);
+    d(this, "frontierConverged", !0);
+    d(this, "pendingFrontierSplats", 0);
+    d(this, "staleResidentSplats", 0);
+    d(this, "lastPlanAppends", 0);
+    d(this, "lastPlanMoves", 0);
+    d(this, "lastPlanGeneration", 0);
+    d(this, "lastPlanBudget", 0);
+    d(this, "lastPlanCamera", null);
+    d(this, "firstFrontierCamera", null);
     /** Monotonic reschedule id; a stale plan (superseded by a newer request) is
      * dropped. `pageTableInFlight` coalesces to one outstanding traversal. */
-    u(this, "pageTableSeq", 0);
-    u(this, "pageTableInFlight", !1);
-    u(this, "pageTableDisposed", !1);
+    d(this, "pageTableSeq", 0);
+    d(this, "pageTableInFlight", !1);
+    d(this, "pageTableDisposed", !1);
     /** Files whose data has been forwarded to the worker (so we don't refetch). */
-    u(this, "pageTableCachedFiles", /* @__PURE__ */ new Set());
+    d(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. */
-    u(this, "pageTableFetchPriority", []);
+    d(this, "pageTableFetchPriority", []);
     /** Frontier-cut target node size (px) and foveation ramp; see `frontierView`. */
-    u(this, "pageTableTargetPx", ie);
-    u(this, "pageTableFoveation", fe);
+    d(this, "pageTableTargetPx", ie);
+    d(this, "pageTableFoveation", fe);
     /** Drawing-buffer height, sampled in `update` so `reschedule` can derive the
      * cut limit the same way the material does (`targetPx / focalY`). */
-    u(this, "pageTableViewportY", 0);
+    d(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. */
-    u(this, "pageTableLimit", 0.02);
+    d(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.
@@ -686,51 +686,51 @@ class Y extends Ee {
      * 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.
      */
-    u(this, "pageTableCacheAtLimit", !1);
+    d(this, "pageTableCacheAtLimit", !1);
     /** Per-splat channels whose edits survive chunk eviction/reload (M7.6). */
-    u(this, "persistentChannels", /* @__PURE__ */ new Map());
+    d(this, "persistentChannels", /* @__PURE__ */ new Map());
     /** Chunk-file index of the always-resident environment tile, if the scene ships one. */
-    u(this, "envFile");
+    d(this, "envFile");
     /** Whether the environment tile should be visible; toggled live. */
-    u(this, "envEnabled");
+    d(this, "envEnabled");
     /** Pool handle of the environment tile once it has loaded (kept for toggling). */
-    u(this, "envHandle");
+    d(this, "envHandle");
     /** Env splat count, measured when the tile decodes; 0 until then. */
-    u(this, "envSplatCount", 0);
+    d(this, "envSplatCount", 0);
     /** Set when the env tile is larger than the whole pool - terminal, warned once. */
-    u(this, "envUnfit", !1);
+    d(this, "envUnfit", !1);
     /**
      * Startup hold. `'capture'` waits for the first schedule after the host
      * applies the final camera; `'holding'` freezes that coverage set.
      */
-    u(this, "initialRevealPhase", "off");
+    d(this, "initialRevealPhase", "off");
     /** Which hold, if any, was armed at construction. Survives release for recapture. */
-    u(this, "initialRevealHold", "off");
+    d(this, "initialRevealHold", "off");
     /** Frozen nearby-detail / in-view coverage runs for {@link initialRevealPhase} `'holding'`. */
-    u(this, "frozenCriticalRuns", null);
+    d(this, "frozenCriticalRuns", null);
     /** Timestamp of the final-camera capture that began the current hold. */
-    u(this, "initialRevealStartedAt");
-    u(this, "initialRevealStateValue", { status: "disabled" });
+    d(this, "initialRevealStartedAt");
+    d(this, "initialRevealStateValue", { status: "disabled" });
     /** Fetch settings this mesh was loaded with, reused for collision meshes. */
-    u(this, "requestOptions");
+    d(this, "requestOptions");
     /** In-flight or settled collision load; see {@link loadCollisionMeshes}. */
-    u(this, "collisionTiles");
-    u(this, "collisionAbort");
-    u(this, "pendingWork", !0);
-    u(this, "lastScheduleTime", -1 / 0);
+    d(this, "collisionTiles");
+    d(this, "collisionAbort");
+    d(this, "pendingWork", !0);
+    d(this, "lastScheduleTime", -1 / 0);
     /** Reused leaf-coverage bitmap for {@link substituteCoverage}; grows only. */
-    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 = {
+    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 = o, this.appendCap = Qe(n.maxSplatsPerSwap);
+    const r = n.initialReveal === "hold-coverage" && this.scene.source.coverageRunsFor !== void 0, c = n.initialReveal === "hold-near-l0" && o;
+    r || c ? (this.initialRevealHold = r ? "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 = (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({
+    }) : (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 = (h = e.environment) == null ? void 0 : h.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: () => {
@@ -742,7 +742,7 @@ class Y extends Ee {
       },
       shedFetches: (m) => this.abortFetches(m)
     });
-    const h = j(n.foveationMode), f = h ? Math.max(
+    const u = j(n.foveationMode), f = u ? Math.max(
       this.cpuCacheBytes,
       Math.min(St, bt(e))
     ) : this.cpuCacheBytes;
@@ -757,13 +757,13 @@ class Y extends Ee {
       },
       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)) {
+    }), this.cacheLimitBytes = this.cacheBudget && this.cacheBudgetHandle ? this.cacheBudget.allowanceFor(this.cacheBudgetHandle) : f, u || (this.cpuCacheBytes = this.cacheLimitBytes), this.fetchCountsValue.cacheLimitBytes = this.cacheLimitBytes, j(n.foveationMode)) {
       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 ?? 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, 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({
+      }), this.slabPageSplats = Math.min(ge, s), this.slabCeiling = s, 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,
@@ -790,9 +790,9 @@ class Y extends Ee {
    * failure, or a `DOMException` named `AbortError` when `options.signal` fires.
    */
   static async load(e, t = {}) {
-    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";
+    const s = Ae(e, t.baseUrl).href, n = s.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(i, t.request),
+      nt(s, t.request),
       a,
       t
     );
@@ -812,9 +812,9 @@ class Y extends Ee {
    * `DOMException` named `AbortError` when `options.signal` fires.
    */
   static async loadLocal(e, t = {}) {
-    let i;
+    let s;
     try {
-      i = ot(e);
+      s = ot(e);
     } catch (n) {
       throw n instanceof q ? n : new q(n instanceof Error ? n.message : String(n), {
         phase: "manifest",
@@ -824,42 +824,42 @@ class Y extends Ee {
       });
     }
     try {
-      const n = await Y.fromSource(i.source, i.format, t);
-      return n.localSource = i.source, n;
+      const n = await Y.fromSource(s.source, s.format, t);
+      return n.localSource = s.source, n;
     } catch (n) {
-      throw i.source.dispose(), n;
+      throw s.source.dispose(), n;
     }
   }
   /** Shared load path: fetch the manifest from a source, then build the scene. */
-  static async fromSource(e, t, i) {
-    const n = i.deviceProfile, a = W(i.budget, n, {
+  static async fromSource(e, t, s) {
+    const n = s.deviceProfile, a = W(s.budget, n, {
       format: t,
-      ...i.budgetCap === void 0 ? {} : { cap: i.budgetCap }
-    }), r = i.maxBudget === void 0 ? a : W(i.maxBudget, n);
-    if (r < a)
+      ...s.budgetCap === void 0 ? {} : { cap: s.budgetCap }
+    }), o = s.maxBudget === void 0 ? a : W(s.maxBudget, n);
+    if (o < a)
       throw new RangeError(
-        `StreamedSplatMesh: maxBudget (${r}) must be >= budget (${a}).`
+        `StreamedSplatMesh: maxBudget (${o}) must be >= budget (${a}).`
       );
-    const l = {
-      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();
+    const r = {
+      budget: o,
+      lodBaseDistance: s.lodBaseDistance ?? 10,
+      lodMultiplier: s.lodMultiplier ?? 2
+    }, c = s.shBands ?? (Ge(s.performanceProfile, n) === "smooth" ? 0 : Ne), u = Pe(n), f = (s.allowFinestLevelLift === !0 || s.budget === void 0 && s.maxBudget === void 0) && s.budgetCap === void 0, h = s.signal;
+    h == null || h.throwIfAborted();
     let g;
     if (t === "rad")
       try {
         const { buildRadScene: p } = await import("./formats/rad.js");
-        g = await p(e, l, i.request, c, f);
+        g = await p(e, r, s.request, c, f);
       } catch (p) {
-        throw N(p) ? p : _(p, { phase: "manifest", url: e.manifestUrl });
+        throw D(p) ? p : _(p, { phase: "manifest", url: e.manifestUrl });
       }
     else {
       let p;
       try {
-        p = await fetch(e.manifestUrl, ee(i.request, d));
+        p = await fetch(e.manifestUrl, ee(s.request, h));
       } catch (S) {
-        throw N(S) ? S : _(S, { phase: "fetch", url: e.manifestUrl });
+        throw D(S) ? S : _(S, { phase: "fetch", url: e.manifestUrl });
       }
       if (!p.ok)
         throw _(
@@ -869,45 +869,44 @@ class Y extends Ee {
       try {
         const S = await p.json();
         if (t === "lcc2") {
-          const { buildLcc2Scene: M } = await import("./formats/lcc.js");
-          g = M(S, e, l, i.shBands ?? 0);
+          const { buildLcc2Scene: F } = await import("./formats/lcc.js");
+          g = F(S, e, r, s.shBands ?? 0);
         } else if (t === "lcc") {
-          const { buildLccScene: M } = await import("./formats/lcc.js");
-          g = await M(S, e, { ...l, shBands: c });
+          const { buildLccScene: F } = await import("./formats/lcc.js");
+          g = await F(S, e, { ...r, shBands: c });
         } else
-          g = tt(S, e, l, i.shBands ?? 0);
+          g = tt(S, e, r, s.shBands ?? 0);
       } catch (S) {
-        throw N(S) ? S : _(S, { phase: "manifest", url: e.manifestUrl });
+        throw D(S) ? S : _(S, { phase: "manifest", url: e.manifestUrl });
       }
     }
-    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);
+    h == null || h.throwIfAborted();
+    const v = (t === "lcc" || t === "rad") && f ? ke(o, g.maxResidentSplats, n) : o, m = s.maxBudget === void 0 ? v : Math.min(a, v);
     g.source.budget = m;
-    const b = Math.min(v, g.maxResidentSplats), T = i.experimentalStagedSwaps !== !1 ? 1.5 : 1.4, I = Math.max(
+    const b = Math.min(v, g.maxResidentSplats), I = s.experimentalStagedSwaps !== !1 ? 1.5 : 1.4, T = Math.max(
       1,
-      Math.ceil(b * T / F)
+      Math.ceil(b * I / B)
     ), y = g.foveation ? ne(
-      i.foveationMode,
+      s.foveationMode,
       t === "rad" ? "page-table" : "frontier"
-    ) : i.foveationMode === void 0 ? void 0 : ne(i.foveationMode);
+    ) : s.foveationMode === void 0 ? void 0 : ne(s.foveationMode);
     let A;
     if (j(y)) {
-      A = (await import("./frontier-worker-CAnK_Cmu.js")).default, d == null || d.throwIfAborted();
+      A = (await import("./frontier-worker-CAnK_Cmu.js")).default, h == null || h.throwIfAborted();
       const S = g.source;
       S.needsParentSizes !== void 0 && (S.needsParentSizes = !1);
     }
     const R = new Y(
       g,
       m,
-      I * F,
+      T * B,
       {
-        ...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" && i.initialReveal === void 0 ? { initialReveal: "hold-near-l0" } : {},
-        ...t === "lcc2" && i.initialReveal === void 0 ? { initialReveal: "hold-coverage" } : {},
+        ...s,
+        // Classic `.lcc` and `.lcc2` wait for in-view coverage so first paint
+        // has no empty cells (classic nearby cells at L1, farther at coarsest).
+        // Keep every other format progressive, and let a caller explicitly
+        // request progressive or hold-near-l0.
+        ...(t === "lcc" || t === "lcc2") && s.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,
@@ -923,7 +922,7 @@ class Y extends Ee {
         // 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: i.antialias ?? (t === "rad" ? !0 : void 0),
+        antialias: s.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
@@ -935,8 +934,8 @@ class Y extends Ee {
         // same 4 ceiling `.rad` was the only format escaping. An explicit
         // `maxStdDev` still wins, through `...options` above.
         ...t === "rad" ? {
-          lodAlpha: i.lodAlpha ?? !0,
-          ...i.maxStdDev === void 0 && h !== void 0 ? { maxStdDev: h } : {}
+          lodAlpha: s.lodAlpha ?? !0,
+          ...s.maxStdDev === void 0 && u !== void 0 ? { maxStdDev: u } : {}
         } : {},
         // 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
@@ -952,7 +951,7 @@ class Y extends Ee {
       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), d != null && d.aborted && (R.dispose(), d.throwIfAborted()), R;
+    return L && (R.matrix.copy(L), R.matrix.decompose(R.position, R.quaternion, R.scale), R.matrixWorldNeedsUpdate = !0), h != null && h.aborted && (R.dispose(), h.throwIfAborted()), R;
   }
   /** Slots the currently reserved pages can hold. */
   get slabSlots() {
@@ -974,47 +973,47 @@ class Y extends Ee {
   syncSlabPages(e) {
     if (this.slabCeiling === 0) return;
     const t = Math.max(this.slabPageSplats, Math.min(this.slabCeiling, e));
-    let i = this.slabSlots;
-    for (; i < t; ) {
-      const n = Math.min(this.slabPageSplats, this.slabCeiling - i);
+    let s = this.slabSlots;
+    for (; s < t; ) {
+      const n = Math.min(this.slabPageSplats, this.slabCeiling - s);
       if (n <= 0) break;
       try {
         this.slabPages.push(this.reserveInactiveRange(n));
       } catch {
         break;
       }
-      i += n;
+      s += n;
     }
     for (; this.slabPages.length > 1; ) {
       const n = this.slabPages[this.slabPages.length - 1];
-      if (i - n.count < t) break;
-      this.slabPages.pop(), i -= n.count, this.removeRange(n);
+      if (s - n.count < t) break;
+      this.slabPages.pop(), s -= n.count, this.removeRange(n);
     }
-    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);
+    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);
   }
   /**
    * 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, i) {
+  writeSlabSlots(e, t, s) {
     let n = 0;
-    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;
+    for (; n < s; ) {
+      const a = t + n, o = this.slabPages[Math.floor(a / this.slabPageSplats)];
+      if (!o) return;
+      const r = a % this.slabPageSplats, c = Math.min(s - n, this.slabPageSplats - r);
+      this.overwriteRangeData(o, K(e, n, c), r), n += c;
     }
   }
   /** Zeros slots `[slot, slot + count)`, splitting at page boundaries like
    * {@link writeSlabSlots}, so freed slots hold nothing drawable. */
   degenerateSlabSlots(e, t) {
-    let i = 0;
-    for (; i < t; ) {
-      const n = e + i, a = this.slabPages[Math.floor(n / this.slabPageSplats)];
+    let s = 0;
+    for (; s < t; ) {
+      const n = e + s, 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;
+      const o = n % this.slabPageSplats, r = Math.min(t - s, this.slabPageSplats - o);
+      this.degenerateRange(a, o, r), s += r;
     }
   }
   /**
@@ -1026,17 +1025,17 @@ class Y extends Ee {
    */
   setSlabResident(e) {
     for (let t = 0; t < this.slabPages.length; t++) {
-      const i = Math.min(
+      const s = Math.min(
         this.slabPageSplats,
         Math.max(0, e - t * this.slabPageSplats)
       );
-      this.setRangeActivePrefix(this.slabPages[t], i);
+      this.setRangeActivePrefix(this.slabPages[t], s);
     }
   }
   /** Typed post to the frontier worker. */
   postToWorker(e, t = []) {
-    var i;
-    (i = this.frontierWorker) == null || i.postMessage(e, t);
+    var s;
+    (s = this.frontierWorker) == null || s.postMessage(e, t);
   }
   /**
    * Applies a new decoded-chunk allowance from the scene's shared
@@ -1087,28 +1086,28 @@ class Y extends Ee {
     const t = this.scene.collision;
     if (!t || t.meshes.length === 0) return [];
     if (!this.collisionTiles) {
-      const r = new AbortController();
-      this.collisionAbort = r, this.collisionTiles = import("./formats/lcc.js").then(
-        ({ loadCollisionMeshTiles: l }) => l(t, {
+      const o = new AbortController();
+      this.collisionAbort = o, this.collisionTiles = import("./formats/lcc.js").then(
+        ({ loadCollisionMeshTiles: r }) => r(t, {
           ...this.requestOptions ? { request: this.requestOptions } : {},
-          signal: r.signal
+          signal: o.signal
         })
-      ).catch((l) => {
-        throw this.collisionTiles = void 0, l;
+      ).catch((r) => {
+        throw this.collisionTiles = void 0, r;
       });
     }
-    const { signal: i } = e;
-    if (!i) return this.collisionTiles;
+    const { signal: s } = e;
+    if (!s) return this.collisionTiles;
     let n;
     try {
       return await Promise.race([
         this.collisionTiles,
-        new Promise((r, l) => {
-          n = () => l(Ke(i)), i.addEventListener("abort", n, { once: !0 });
+        new Promise((o, r) => {
+          n = () => r(Ke(s)), s.addEventListener("abort", n, { once: !0 });
         })
       ]);
     } finally {
-      n && i.removeEventListener("abort", n);
+      n && s.removeEventListener("abort", n);
     }
   }
   /**
@@ -1344,15 +1343,15 @@ class Y extends Ee {
   set lodBaseDistance(e) {
     this.scene.source.lodBaseDistance = e, this.pendingWork = !0;
   }
-  update(e, t, i = {}) {
+  update(e, t, s = {}) {
     const n = performance.now();
     e.updateMatrixWorld(), this.updateWorldMatrix(!0, !1);
     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 o = (a == null ? void 0 : a.head) ?? e, r = this.shouldReschedule(o, n) ? this.reschedule(o, n) : null;
+    if (super.update(e, t, s), r && 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);
+      r.cpuMs += performance.now() - r.timestamp, r.activeListMs = c.activeListMs, r.uploadMs = c.uploadMs, r.sortSubmitMs = c.sortSubmitMs, r.stagingTextureAllocations = c.stagingTextureAllocations, r.activeListUpdateRanges = c.activeListUpdateRanges, this.onPerformanceEvent(r);
     }
   }
   /** Root bounds of the whole scene, valid before any chunk has loaded. */
@@ -1368,10 +1367,10 @@ class Y extends Ee {
   setLodLevelDebug(e) {
     if (e) {
       this.lodLevelChannelReady || (this.defineChannel("lodLevel", { type: "float", fill: -1 }), this.lodLevelChannelReady = !0), this.lodLevelDebug = !0;
-      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);
+      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);
       return;
     }
     this.lodLevelDebug = !1;
@@ -1445,39 +1444,39 @@ class Y extends Ee {
    * @throws {Error} if the channel was not declared with
    *   {@link definePersistentChannel}.
    */
-  paintPersistent(e, t, i, n) {
+  paintPersistent(e, t, s, 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 r = i * i;
-    let l = 0;
+    const o = s * s;
+    let r = 0;
     const c = /* @__PURE__ */ new Set();
-    for (const { run: h } of this.resident.values()) {
-      const f = this.cache.get(h.file);
+    for (const { run: u } of this.resident.values()) {
+      const f = this.cache.get(u.file);
       if (!f) continue;
-      const d = f.data.positions, g = a.edits.get(h.file) ?? /* @__PURE__ */ new Map();
+      const h = f.data.positions, g = a.edits.get(u.file) ?? /* @__PURE__ */ new Map();
       let v = !1;
-      for (let m = 0; m < h.count; m++) {
-        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)) {
+      for (let m = 0; m < u.count; m++) {
+        const b = u.offset + m, I = h[b * 3 + 0] - V.x, T = h[b * 3 + 1] - V.y, y = h[b * 3 + 2] - V.z;
+        if (!(I * I + T * T + y * y > o) && !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;
           }
-          a.total++, g.set(b, n), v = !0, l++;
+          a.total++, g.set(b, n), v = !0, r++;
         }
       }
-      v && (a.edits.set(h.file, g), c.add(h.file));
+      v && (a.edits.set(u.file, g), c.add(u.file));
     }
     if (c.size > 0)
-      for (const { run: h, handle: f } of this.resident.values())
-        c.has(h.file) && this.applyPersistentRun(e, a, h, f);
-    return l;
+      for (const { run: u, handle: f } of this.resident.values())
+        c.has(u.file) && this.applyPersistentRun(e, a, u, f);
+    return r;
   }
   /**
    * Clears every stored edit for a persistent channel and zeroes the value on
@@ -1493,20 +1492,20 @@ class Y extends Ee {
         `StreamedSplatMesh.clearPersistentChannel: channel "${e}" is not a persistent channel.`
       );
     t.edits.clear(), t.total = 0;
-    for (const { run: i, handle: n } of this.resident.values()) {
-      const a = t.type === "byte" ? new Uint8Array(i.count) : new Float32Array(i.count);
+    for (const { run: s, handle: n } of this.resident.values()) {
+      const a = t.type === "byte" ? new Uint8Array(s.count) : new Float32Array(s.count);
       this.writeChannel(n, e, a);
     }
   }
   dispose() {
-    var e, t, i, n, a;
+    var e, t, s, 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: 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);
+      for (const { controller: o } of this.fetching.values()) o.abort();
+      if (this.fetching.clear(), this.fetchHandle && ((s = this.fetchScheduler) == null || s.unregister(this.fetchHandle)), this.cacheBudgetHandle) {
+        const o = this.cacheBudgetHandle;
+        this.cacheBudgetHandle = void 0, (n = this.cacheBudget) == null || n.unregister(o);
       }
       (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();
     }
@@ -1514,12 +1513,12 @@ class Y extends Ee {
   shouldReschedule(e, t) {
     if (this.pendingWork || t - this.lastScheduleTime > ft) return !0;
     e.getWorldPosition(pe);
-    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);
+    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);
   }
   reschedule(e, t) {
     var L;
-    const i = performance.now();
+    const s = performance.now();
     let n = null;
     if (this.onPerformanceEvent !== void 0) {
       n = { resident: /* @__PURE__ */ new Map(), staged: /* @__PURE__ */ new Map() };
@@ -1528,13 +1527,13 @@ class Y extends Ee {
     }
     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();
+      e.getWorldDirection(M).add(this.lastCameraPos), this.worldToLocal(M), M.sub(x).normalize();
       const p = e.projectionMatrix.elements[5] * this.pageTableViewportY / 2;
-      if (p > 0 && (this.pageTableLimit = this.pageTableTargetPx / p), this.reschedulePageTable(x, B, O, t), this.onPerformanceEvent === void 0) return null;
+      if (p > 0 && (this.pageTableLimit = this.pageTableTargetPx / p), this.reschedulePageTable(x, M, O, t), this.onPerformanceEvent === void 0) return null;
       const S = performance.now();
       return {
         timestamp: S,
-        cpuMs: S - i,
+        cpuMs: S - s,
         activeListMs: 0,
         uploadMs: 0,
         sortSubmitMs: 0,
@@ -1549,35 +1548,36 @@ class Y extends Ee {
         compacted: !1
       };
     }
-    e.getWorldDirection(B).add(this.lastCameraPos), this.worldToLocal(B), B.sub(x).normalize();
-    const r = this.scene.source.computeDesiredRuns(
+    e.getWorldDirection(M).add(this.lastCameraPos), this.worldToLocal(M), M.sub(x).normalize();
+    const o = this.scene.source.computeDesiredRuns(
       x,
       O,
       t,
-      B
-    ), l = this.captureOrContinueInitialReveal(
-      r,
+      M
+    ), r = this.captureOrContinueInitialReveal(
+      o,
       t,
       x,
-      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), d.add(p.file);
+      O,
+      M
+    ), c = r !== null, u = r ?? o, f = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Set();
+    for (const p of u)
+      f.set(C(p), p), h.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));
+      f.has(p) || c && ((L = this.frozenCriticalRuns) != null && L.some((F) => C(F) === p)) || (this.removeRange(S.handle), this.staged.delete(p));
     for (const [p, { controller: S }] of this.fetching)
-      !d.has(p) && !this.scene.pinnedFiles.has(p) && S.abort();
+      !h.has(p) && !this.scene.pinnedFiles.has(p) && S.abort();
     for (const p of this.retrying.keys())
-      !d.has(p) && !this.scene.pinnedFiles.has(p) && this.retrying.delete(p);
+      !h.has(p) && !this.scene.pinnedFiles.has(p) && this.retrying.delete(p);
     this.neededFiles.clear();
-    for (const p of h) {
+    for (const p of u) {
       const S = C(p);
       if (this.resident.has(S)) continue;
-      const M = this.staged.get(S);
-      M && M.uploadedCount === p.count || this.neededFiles.add(p.file);
+      const F = this.staged.get(S);
+      F && F.uploadedCount === p.count || this.neededFiles.add(p.file);
     }
     this.envFile !== void 0 && this.envEnabled && this.envHandle === void 0 && !this.envUnfit && !this.failedFiles.has(this.envFile) && this.neededFiles.add(this.envFile);
-    const g = h.filter((p) => !this.resident.has(C(p))), v = c ? [] : [...this.resident.entries()].filter(([p]) => !f.has(p)), m = c ? (
+    const g = u.filter((p) => !this.resident.has(C(p))), v = c ? [] : [...this.resident.entries()].filter(([p]) => !f.has(p)), m = c ? (
       // Mesh is invisible during the hold, so L0 cell-atomicity (no holes) is
       // irrelevant - commit each frozen slice as it lands so a partial home
       // cell cannot block reveal behind sibling subchunks still fetching.
@@ -1586,12 +1586,12 @@ class Y extends Ee {
     m.sort(
       (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;
+    const I = /* @__PURE__ */ new Map();
+    this.updateEnvironment(t, I);
+    let T = 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 < ut) {
+        if (this.neverRetireCoverageEarly || !A && this.retireHeldTicks < dt) {
           this.pendingWork = !0, R = !0;
           continue;
         }
@@ -1601,25 +1601,25 @@ class Y extends Ee {
         this.applyGroup(p, t);
         continue;
       }
-      const S = p.adds.filter((P) => !this.cache.has(P.file)), M = c || Ye(p) && this.initialRevealHold !== "hold-coverage";
+      const S = p.adds.filter((P) => !this.cache.has(P.file)), F = c || Ye(p) && this.initialRevealHold !== "hold-coverage";
       if (S.length > 0) {
         let P = !1;
         for (const k of S)
           this.failedFiles.has(k.file) || (oe(
-            T,
+            I,
             k.file,
             qe(k, this.scene.source.lodBaseDistance),
             k
           ), P = !0);
-        if (c || this.substituteCoverage(p, t, T, M), P && (this.pendingWork = !0, y = !0), !c) continue;
+        if (c || this.substituteCoverage(p, t, I, F), 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 P = this.stageGroup(p, t, Math.max(0, this.appendCap - I));
-        if (I += P, !p.adds.every((k) => {
+        const P = this.stageGroup(p, t, Math.max(0, this.appendCap - T));
+        if (T += P, !p.adds.every((k) => {
           var se;
           return ((se = this.staged.get(C(k))) == null ? void 0 : se.uploadedCount) === k.count;
         })) {
@@ -1633,7 +1633,7 @@ class Y extends Ee {
         this.commitStagedGroup(p);
         continue;
       }
-      if (!c && I > 0 && I + p.addCount > this.appendCap) {
+      if (!c && T > 0 && T + p.addCount > this.appendCap) {
         this.pendingWork = !0, y = !0;
         continue;
       }
@@ -1645,17 +1645,17 @@ class Y extends Ee {
         this.pendingWork = !0, A = !0;
         continue;
       }
-      I += p.addCount;
+      T += p.addCount;
     }
-    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(
+    return this.flushClassicFetches(I, 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,
       a,
-      i
+      s
     );
   }
   rowAlignedSplats(e) {
-    return Math.ceil(e / F) * F;
+    return Math.ceil(e / B) * B;
   }
   /**
    * Startup hold seeds: the coverage group containing (or nearest to) the
@@ -1666,68 +1666,68 @@ class Y extends Ee {
    */
   selectHomeSeedRuns(e) {
     var a;
-    const t = this.scene.source.lodBaseDistance, i = e.filter(
-      (r) => r.coverageGroup !== void 0 && (r.distance ?? Number.POSITIVE_INFINITY) <= t
+    const t = this.scene.source.lodBaseDistance, s = e.filter(
+      (o) => o.coverageGroup !== void 0 && (o.distance ?? Number.POSITIVE_INFINITY) <= t
     ).sort(
-      (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);
+      (o, r) => (o.distance ?? Number.POSITIVE_INFINITY) - (r.distance ?? Number.POSITIVE_INFINITY) || // Same distance: prefer in-view, then finer.
+      (o.inView === !0 ? 0 : 1) - (r.inView === !0 ? 0 : 1) || o.level - r.level || o.leafStart - r.leafStart
+    ), n = (a = s[0]) == null ? void 0 : a.coverageGroup;
+    return n === void 0 ? [] : s.filter((o) => o.coverageGroup === n);
   }
   coarsenHomeRuns(e, t) {
     var a;
-    const i = [], n = this.scene.source;
-    for (const r of e) {
-      if (r.level === t) {
-        i.push(r);
+    const s = [], n = this.scene.source;
+    for (const o of e) {
+      if (o.level === t) {
+        s.push(o);
         continue;
       }
-      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)
-          i.push({
+      const r = ((a = n.runsAtLevelFor) == null ? void 0 : a.call(n, o.leafStart, o.leafEnd, t)) ?? [];
+      if (r.length !== 0)
+        for (const c of r)
+          s.push({
             ...c,
-            distance: r.distance,
-            inView: r.inView,
-            ...r.coverageGroup === void 0 ? {} : { coverageGroup: r.coverageGroup },
-            ...r.screenImportance === void 0 ? {} : { screenImportance: r.screenImportance }
+            distance: o.distance,
+            inView: o.inView,
+            ...o.coverageGroup === void 0 ? {} : { coverageGroup: o.coverageGroup },
+            ...o.screenImportance === void 0 ? {} : { screenImportance: o.screenImportance }
           });
     }
-    return i;
+    return s;
   }
   criticalRunsFitCapacity(e) {
     let t = 0;
-    for (const i of e) t += this.rowAlignedSplats(i.count);
+    for (const s of e) t += this.rowAlignedSplats(s.count);
     return t <= this.freeSplatCapacity;
   }
   publishInitialRevealProgress(e) {
     const t = /* @__PURE__ */ new Map();
-    for (const l of e) {
-      const c = l.coverageGroup !== void 0 ? `g:${l.coverageGroup}` : C(l);
-      let h = t.get(c);
-      h || (h = [], t.set(c, h)), h.push(l);
+    for (const r of e) {
+      const c = r.coverageGroup !== void 0 ? `g:${r.coverageGroup}` : C(r);
+      let u = t.get(c);
+      u || (u = [], t.set(c, u)), u.push(r);
     }
-    let i = 0, n = 0, a = 0;
-    for (const l of t.values()) {
+    let s = 0, n = 0, a = 0;
+    for (const r of t.values()) {
       let c = !0;
-      for (const h of l) {
-        n += h.count;
-        const f = C(h);
+      for (const u of r) {
+        n += u.count;
+        const f = C(u);
         if (this.resident.has(f)) {
-          i += h.count;
+          s += u.count;
           continue;
         }
-        const d = this.staged.get(f);
-        i += (d == null ? void 0 : d.uploadedCount) ?? 0, (!d || d.uploadedCount !== h.count) && (c = !1);
+        const h = this.staged.get(f);
+        s += (h == null ? void 0 : h.uploadedCount) ?? 0, (!h || h.uploadedCount !== u.count) && (c = !1);
       }
       c && a++;
     }
-    const r = this.initialRevealStateValue;
-    if (r.status === "degraded") {
+    const o = this.initialRevealStateValue;
+    if (o.status === "degraded") {
       this.initialRevealStateValue = {
         status: "degraded",
-        reason: r.reason,
-        stagedSplats: i,
+        reason: o.reason,
+        stagedSplats: s,
         totalSplats: n,
         readyGroups: a,
         totalGroups: t.size
@@ -1736,77 +1736,109 @@ class Y extends Ee {
     }
     this.initialRevealStateValue = {
       status: "pending",
-      stagedSplats: i,
+      stagedSplats: s,
       totalSplats: n,
       readyGroups: a,
       totalGroups: t.size
     };
   }
   releaseInitialReveal(e, t) {
-    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;
+    const s = this.frozenCriticalRuns ?? [];
+    this.publishInitialRevealProgress(s);
+    const n = this.initialRevealStateValue, a = n.status === "pending" || n.status === "degraded" ? n.stagedSplats : 0, o = n.status === "pending" || n.status === "degraded" ? n.totalSplats : 0, r = 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: a,
-      totalSplats: r,
-      readyGroups: l,
+      totalSplats: o,
+      readyGroups: r,
       totalGroups: c
     }, this.frozenCriticalRuns = null, this.initialRevealPhase = "released", this.pendingWork = !0;
   }
   /**
-   * `.lcc2` coverage hold: freeze coarsest covering runs for in-view cells.
+   * Coverage hold: freeze covering runs for in-view cells (classic `.lcc`
+   * physical cells at L1 near / coarsest far, `.lcc2` octree root-children).
    * Missing `coverageRunsFor` (or an empty result after fallback) releases
    * immediately so the mesh does not stay hidden with nothing to fetch.
+   * If the mixed set overflows the pool, coarsen only the near (non-coarsest)
+   * groups one more rung before degrading to progressive.
    */
-  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) {
+  captureCoverageHold(e, t, s, n) {
+    var o, r;
+    let a = ((r = (o = this.scene.source).coverageRunsFor) == null ? void 0 : r.call(o, e, t, n)) ?? [];
+    if (a.length === 0) {
       if (this.environmentPendingForReveal()) {
-        this.frozenCriticalRuns = [], this.initialRevealStartedAt = i, this.initialRevealPhase = "holding", this.publishInitialRevealProgress([]);
+        this.frozenCriticalRuns = [], this.initialRevealStartedAt = s, this.initialRevealPhase = "holding", this.publishInitialRevealProgress([]);
         return;
       }
       this.initialRevealStateValue = { status: "ready" }, this.initialRevealPhase = "released";
       return;
     }
-    if (!this.criticalRunsFitCapacity(n)) {
-      this.frozenCriticalRuns = n, this.releaseInitialReveal("degraded", "capacity");
-      return;
+    if (!this.criticalRunsFitCapacity(a)) {
+      const c = this.coarsenCoverageNearRuns(a);
+      if (this.criticalRunsFitCapacity(c))
+        a = c;
+      else {
+        this.frozenCriticalRuns = a, this.releaseInitialReveal("degraded", "capacity");
+        return;
+      }
+    }
+    this.frozenCriticalRuns = a, this.initialRevealStartedAt = s, this.initialRevealPhase = "holding", this.publishInitialRevealProgress(a);
+  }
+  /**
+   * Bump each coverage run one coarser rung when the source has one. Already-
+   * coarsest (far) runs stay put so a tight pool only drops near L1 → L2.
+   */
+  coarsenCoverageNearRuns(e) {
+    var n;
+    const t = [], s = this.scene.source;
+    for (const a of e) {
+      const o = ((n = s.runsAtLevelFor) == null ? void 0 : n.call(s, a.leafStart, a.leafEnd, a.level + 1)) ?? [];
+      if (o.length === 0 || o.every((r) => r.level <= a.level)) {
+        t.push(a);
+        continue;
+      }
+      for (const r of o)
+        t.push({
+          ...r,
+          distance: a.distance,
+          inView: a.inView,
+          ...a.coverageGroup === void 0 ? {} : { coverageGroup: a.coverageGroup },
+          ...a.screenImportance === void 0 ? {} : { screenImportance: a.screenImportance }
+        });
     }
-    this.frozenCriticalRuns = n, this.initialRevealStartedAt = i, this.initialRevealPhase = "holding", this.publishInitialRevealProgress(n);
+    return t;
   }
-  captureOrContinueInitialReveal(e, t, i, n) {
+  captureOrContinueInitialReveal(e, t, s, n, a) {
     if (this.initialRevealPhase === "off" || this.initialRevealPhase === "released") return null;
     if (this.initialRevealPhase === "capture")
       if (this.initialRevealHold === "hold-coverage")
-        this.captureCoverageHold(i, n, t);
+        this.captureCoverageHold(s, n, t, a);
       else {
-        const a = this.selectHomeSeedRuns(e);
+        const o = 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, 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
+        if (o.length === 0) {
+          const c = this.scene.source.lodBaseDistance * this.scene.source.lodMultiplier * this.scene.source.lodMultiplier, u = e.filter(
+            (h) => h.level <= 2 && h.coverageGroup !== void 0 && (h.distance ?? Number.POSITIVE_INFINITY) <= c
+          ), f = [...u].sort(
+            (h, g) => (h.distance ?? Number.POSITIVE_INFINITY) - (g.distance ?? Number.POSITIVE_INFINITY) || (h.inView === !0 ? 0 : 1) - (g.inView === !0 ? 0 : 1) || (h.screenImportance ?? Number.POSITIVE_INFINITY) - (g.screenImportance ?? Number.POSITIVE_INFINITY) || h.leafStart - g.leafStart
           )[0];
-          if (!h)
+          if (!f)
             return this.initialRevealStateValue = { status: "ready" }, this.initialRevealPhase = "released", null;
-          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)), r.length === 0 || !this.criticalRunsFitCapacity(r))
-            return this.frozenCriticalRuns = r.length > 0 ? r : [h], this.releaseInitialReveal("degraded", "capacity"), null;
+          if (r = f.coverageGroup !== void 0 ? u.filter((h) => h.coverageGroup === f.coverageGroup) : [f], this.criticalRunsFitCapacity(r) || (r = f.coverageGroup !== void 0 ? u.filter(
+            (h) => h.coverageGroup === f.coverageGroup && this.criticalRunsFitCapacity([h])
+          ).slice(0, 1) : u.filter((h) => this.criticalRunsFitCapacity([h])).slice(0, 1)), r.length === 0 || !this.criticalRunsFitCapacity(r))
+            return this.frozenCriticalRuns = r.length > 0 ? r : [f], 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(a, l);
-            if (c.length !== 0) {
-              if (this.criticalRunsFitCapacity(c)) {
-                r = c;
+          for (const c of [0, 1, 2]) {
+            const u = this.coarsenHomeRuns(o, c);
+            if (u.length !== 0) {
+              if (this.criticalRunsFitCapacity(u)) {
+                r = u;
                 break;
               }
-              r = c;
+              r = u;
             }
           }
           if (r.length === 0)
@@ -1819,10 +1851,10 @@ class Y extends Ee {
     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 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)
+    for (const o of this.frozenCriticalRuns)
+      if (this.failedFiles.has(o.file) && !this.resident.has(C(o))) {
+        const r = this.staged.get(C(o));
+        if (!r || r.uploadedCount !== o.count)
           return this.releaseInitialReveal("degraded", "fetch-failed"), null;
       }
     return this.publishInitialRevealProgress(this.frozenCriticalRuns), this.frozenCriticalRuns;
@@ -1839,18 +1871,18 @@ class Y extends Ee {
     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, 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 [d, g] of e)
-      this.resident.has(d) || (l += g);
+  createPerformanceEvent(e, t, s, n) {
+    let a = 0, o = 0;
+    for (const [h, g] of this.resident)
+      o += g.run.count, e.has(h) || (a += g.run.count);
+    let r = 0;
+    for (const [h, g] of e)
+      this.resident.has(h) || (r += g);
     let c = 0;
-    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;
+    for (const [h, g] of this.staged)
+      c += Math.max(0, g.uploadedCount - (t.get(h) ?? 0));
+    const u = this.compactionCount !== s;
+    if (a === 0 && r === 0 && c === 0 && !u) return null;
     const f = performance.now();
     return {
       timestamp: f,
@@ -1861,29 +1893,29 @@ class Y extends Ee {
       stagingTextureAllocations: 0,
       activeListUpdateRanges: 0,
       appendedCount: a,
-      removedCount: l,
+      removedCount: r,
       stagedCount: c,
       uploadCount: a + c,
-      activeCount: r,
-      forcedSort: r === 0 || a + l >= r * ht,
-      compacted: h
+      activeCount: o,
+      forcedSort: o === 0 || a + r >= o * ht,
+      compacted: u
     };
   }
   /** Returns whether all new rows can coexist with the currently visible region. */
   canStageGroup(e) {
-    return e.adds.filter((i) => !this.staged.has(C(i))).reduce((i, n) => i + this.rowAlignedSplats(n.count), 0) <= this.freeSplatCapacity;
+    return e.adds.filter((s) => !this.staged.has(C(s))).reduce((s, n) => s + 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, i) {
-    if (i <= 0) return 0;
+  stageGroup(e, t, s) {
+    if (s <= 0) return 0;
     let n = 0;
     for (const a of e.adds) {
-      const r = C(a), l = this.cache.get(a.file);
-      if (!l) continue;
-      let c = this.staged.get(r);
+      const o = C(a), r = this.cache.get(a.file);
+      if (!r) continue;
+      let c = this.staged.get(o);
       if (!c) {
         let f;
         try {
@@ -1897,36 +1929,36 @@ class Y extends Ee {
             break;
           }
         }
-        c = { run: a, handle: f, uploadedCount: 0 }, this.staged.set(r, c);
+        c = { run: a, handle: f, uploadedCount: 0 }, this.staged.set(o, c);
       }
       if (c.uploadedCount === a.count) continue;
-      const h = Math.min(a.count - c.uploadedCount, i - n);
-      if (h <= 0) break;
+      const u = Math.min(a.count - c.uploadedCount, s - n);
+      if (u <= 0) break;
       if (this.writeInactiveRange(
         c.handle,
-        K(l.data, a.offset + c.uploadedCount, h),
+        K(r.data, a.offset + c.uploadedCount, u),
         c.uploadedCount
-      ), c.uploadedCount += h, l.lastUsed = t, n += h, c.uploadedCount === a.count) {
+      ), c.uploadedCount += u, r.lastUsed = t, n += u, c.uploadedCount === a.count) {
         this.writeLodLevelChannel(c.handle, a.level);
-        for (const [f, d] of this.persistentChannels)
-          this.applyPersistentRun(f, d, a, c.handle);
+        for (const [f, h] of this.persistentChannels)
+          this.applyPersistentRun(f, h, a, c.handle);
       }
-      if (n >= i) break;
+      if (n >= s) 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 i = this.staged.get(C(t));
-      if (!i || i.uploadedCount !== t.count)
+      const s = this.staged.get(C(t));
+      if (!s || s.uploadedCount !== t.count)
         throw new Error("StreamedSplatMesh: incomplete staged group commit.");
     }
-    for (const [t, i] of e.removes)
-      this.resident.has(t) && (this.removeRange(i.handle), this.resident.delete(t));
+    for (const [t, s] of e.removes)
+      this.resident.has(t) && (this.removeRange(s.handle), this.resident.delete(t));
     for (const t of e.adds) {
-      const i = C(t), n = this.staged.get(i);
-      this.setRangeActive(n.handle, !0), this.resident.set(i, n), this.staged.delete(i);
+      const s = C(t), n = this.staged.get(s);
+      this.setRangeActive(n.handle, !0), this.resident.set(s, n), this.staged.delete(s);
     }
   }
   /**
@@ -1936,19 +1968,19 @@ class Y extends Ee {
    * removals - the caller defers it and the old runs keep rendering.
    */
   applyGroup(e, 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);
+    const s = (o) => Math.ceil(o / B) * B, n = e.adds.reduce((o, r) => o + s(r.count), 0), a = e.removes.reduce((o, [, r]) => o + s(r.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);
+    for (const [o, r] of e.removes)
+      this.resident.has(o) && (this.removeRange(r.handle), this.resident.delete(o));
+    for (const o of e.adds)
+      this.appendRun(o, t);
     return !0;
   }
   /** Appends one run from the cache, compacting the pool on fragmentation. */
   appendRun(e, t) {
-    const i = this.cache.get(e.file);
-    if (!i) return;
-    const n = K(i.data, e.offset, e.count);
+    const s = this.cache.get(e.file);
+    if (!s) return;
+    const n = K(s.data, e.offset, e.count);
     let a;
     try {
       a = this.appendRange(n);
@@ -1961,25 +1993,25 @@ class Y extends Ee {
         return;
       }
     }
-    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);
+    this.resident.set(C(e), { run: e, handle: a }), s.lastUsed = t, this.writeLodLevelChannel(a, e.level);
+    for (const [o, r] of this.persistentChannels)
+      this.applyPersistentRun(o, r, 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, i, n) {
-    const a = t.edits.get(i.file);
+  applyPersistentRun(e, t, s, n) {
+    const a = t.edits.get(s.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 < i.count; c++) {
-      const h = a.get(i.offset + c);
-      h !== void 0 && (r[c] = h, l = !0);
+    const o = t.type === "byte" ? new Uint8Array(s.count) : new Float32Array(s.count);
+    t.fill && o.fill(t.fill);
+    let r = !1;
+    for (let c = 0; c < s.count; c++) {
+      const u = a.get(s.offset + c);
+      u !== void 0 && (o[c] = u, r = !0);
     }
-    l && this.writeChannel(n, e, r);
+    r && this.writeChannel(n, e, o);
   }
   /**
    * Covers a deferred group's leaves that no resident run covers with each
@@ -1992,21 +2024,21 @@ class Y extends Ee {
    * paint and its pin fetch entirely - cold load requests only the target cut
    * for that cell. Far gaps keep the shell.
    */
-  substituteCoverage(e, t, i, n) {
+  substituteCoverage(e, t, s, 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), d = Math.min(h.leafEnd, e.leafEnd);
-      d > f && r.fill(1, f - e.leafStart, d - e.leafStart);
+    const o = this.coverageScratch;
+    o.fill(0, 0, a);
+    for (const { run: u } of this.resident.values()) {
+      const f = Math.max(u.leafStart, e.leafStart), h = Math.min(u.leafEnd, e.leafEnd);
+      h > f && o.fill(1, f - e.leafStart, h - e.leafStart);
     }
-    const l = r.subarray(0, a);
+    const r = o.subarray(0, a);
     let c = 0;
     for (; c < a; ) {
-      const h = l.indexOf(0, c);
-      if (h < 0) break;
-      const f = l.indexOf(1, h), d = f < 0 ? a : f, g = e.leafStart + h, v = e.leafStart + d;
+      const u = r.indexOf(0, c);
+      if (u < 0) break;
+      const f = r.indexOf(1, u), h = f < 0 ? a : f, g = e.leafStart + u, v = e.leafStart + h;
       for (const m of this.scene.source.coarsestRunsFor(g, v))
         if (!this.resident.has(C(m))) {
           if (n) {
@@ -2015,29 +2047,29 @@ class Y extends Ee {
           }
           if (!this.cache.has(m.file)) {
             oe(
-              i,
+              s,
               m.file,
               je(m, this.scene.source.lodBaseDistance),
               m
             ), this.fetchCountsValue.uncovered += Math.min(m.leafEnd, v) - Math.max(m.leafStart, g);
             continue;
           }
-          for (const [b, T] of this.resident)
-            T.run.leafStart < m.leafEnd && T.run.leafEnd > m.leafStart && (this.removeRange(T.handle), this.resident.delete(b));
+          for (const [b, I] of this.resident)
+            I.run.leafStart < m.leafEnd && I.run.leafEnd > m.leafStart && (this.removeRange(I.handle), this.resident.delete(b));
           this.appendRun(m, t);
         }
-      c = d;
+      c = h;
     }
   }
   /** Issues pending classic-path chunk wants in group-priority order. */
-  flushClassicFetches(e, t, i = !1) {
+  flushClassicFetches(e, t, s = !1) {
     if (e.size === 0) return;
-    $e(e, t, i);
+    $e(e, t, s);
     const n = [...e.entries()].sort(
-      (a, r) => X(a[1], r[1], a[0], r[0])
+      (a, o) => X(a[1], o[1], a[0], o[0])
     );
     this.preemptClassicFetches(n);
-    for (const [a, r] of n) this.requestChunk(a, r.kind, r);
+    for (const [a, o] of n) this.requestChunk(a, o.kind, o);
   }
   /**
    * A camera turn must not wait for all eight old visible requests to finish.
@@ -2046,12 +2078,12 @@ class Y extends Ee {
    */
   preemptClassicFetches(e) {
     var t;
-    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 && (!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;
+    for (const [s, n] of e) {
+      if (this.cache.has(s) || this.fetching.has(s)) continue;
+      let a, o;
+      for (const [r, c] of this.fetching)
+        c.classicWant && (!o || X(c.classicWant, o, r, a) > 0) && (a = r, o = c.classicWant);
+      if (o && a !== void 0 && X(n, o, s, a) < 0 && ((t = this.fetching.get(a)) == null || t.controller.abort()), this.fetching.size >= this.maxInflight) return;
     }
   }
   /**
@@ -2063,15 +2095,15 @@ class Y extends Ee {
    * it issues ahead of LOD coverage.
    */
   updateEnvironment(e, t) {
-    const i = this.envFile;
-    if (i === void 0 || this.envHandle !== void 0 || !this.envEnabled || this.envUnfit)
+    const s = this.envFile;
+    if (s === void 0 || this.envHandle !== void 0 || !this.envEnabled || this.envUnfit)
       return;
-    const n = this.cache.get(i);
+    const n = this.cache.get(s);
     if (!n) {
-      this.failedFiles.has(i) || (t ? this.enqueueEnvironmentFetch(t, i) : this.requestChunk(i, "priority"), this.pendingWork = !0);
+      this.failedFiles.has(s) || (t ? this.enqueueEnvironmentFetch(t, s) : this.requestChunk(s, "priority"), this.pendingWork = !0);
       return;
     }
-    const a = Math.ceil(n.data.count / F) * F;
+    const a = Math.ceil(n.data.count / B) * B;
     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.`
@@ -2082,19 +2114,19 @@ class Y extends Ee {
       this.pendingWork = !0;
       return;
     }
-    let r;
+    let o;
     try {
-      r = this.appendRange(n.data);
+      o = this.appendRange(n.data);
     } catch {
       this.compactionCount++, this.compact();
       try {
-        r = this.appendRange(n.data);
+        o = this.appendRange(n.data);
       } catch {
         this.pendingWork = !0;
         return;
       }
     }
-    this.envHandle = r, this.envSplatCount = n.data.count, n.lastUsed = e;
+    this.envHandle = o, this.envSplatCount = n.data.count, n.lastUsed = e;
   }
   /** Ranks the env tile ahead of every LOD want in {@link flushClassicFetches}. */
   enqueueEnvironmentFetch(e, t) {
@@ -2123,16 +2155,16 @@ class Y extends Ee {
    * 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, i, n) {
-    for (const r of this.pageTableFetchPriority) this.requestChunk(r, "priority");
+  reschedulePageTable(e, t, s, n) {
+    for (const o of this.pageTableFetchPriority) this.requestChunk(o, "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();
+    for (const o of this.scene.source.computeDesiredRuns(e, s, n))
+      a.add(o.file), this.requestChunk(o.file, "base");
+    for (const [o, r] of this.fetching)
+      r.kind !== "sweep" && !a.has(o) && !this.scene.pinnedFiles.has(o) && r.controller.abort();
     if (!this.pageTableCacheAtLimit && this.sweepAllowed()) {
-      const r = Math.max(1, this.maxInflight - mt), l = this.scene.chunkUrls.length;
-      for (let c = 0; c < l && this.fetching.size < r; c++)
+      const o = Math.max(1, this.maxInflight - mt), r = this.scene.chunkUrls.length;
+      for (let c = 0; c < r && this.fetching.size < o; c++)
         this.pageTableCachedFiles.has(c) || this.requestChunk(c, "sweep");
     }
     this.pageTableInFlight || (this.pageTableInFlight = !0, this.postToWorker({
@@ -2157,48 +2189,48 @@ class Y extends Ee {
     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 i = performance.now(), n = e.moveSlots;
-    for (let d = 0; d < n.length; ) {
+    const s = performance.now(), n = e.moveSlots;
+    for (let h = 0; h < n.length; ) {
       let g = 1;
-      for (; d + g < n.length && n[d + g] === n[d] + g; )
+      for (; h + g < n.length && n[h + g] === n[h] + g; )
         g++;
-      const v = n[d], m = Math.min(g, t - v);
-      m > 0 && this.writeSlabSlots(yt(e.moves, d, m), v, m), d += g;
+      const v = n[h], m = Math.min(g, t - v);
+      m > 0 && this.writeSlabSlots(yt(e.moves, h, m), v, m), h += g;
     }
     if (e.appends.count > 0) {
-      const d = Math.min(e.appends.count, t - e.appendStart);
-      d > 0 && this.writeSlabSlots(e.appends, e.appendStart, d);
+      const h = Math.min(e.appends.count, t - e.appendStart);
+      h > 0 && this.writeSlabSlots(e.appends, e.appendStart, h);
     }
-    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 = 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(
+    const a = performance.now(), o = Math.min(e.residentCount, t);
+    this.setSlabResident(o);
+    const r = Math.min(e.degenerateStart, t), c = Math.min(e.degenerateCount, t - r);
+    c > 0 && this.degenerateSlabSlots(r, c);
+    const u = performance.now();
+    this.pageTableDrawn = o, 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 - 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);
+    if (f.applyMs = u - s, f.writeMs = a - s, f.residentMs = u - 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 h = Math.min(1, e.solvedLimit / this.pageTableLimit);
       this.setScreenRadiusBand(
-        this.frontierBandBase.min * d,
-        this.frontierBandBase.max * d
+        this.frontierBandBase.min * h,
+        this.frontierBandBase.max * h
       );
     }
     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 d = 0; d < e.evicted.length; d++)
-      this.pageTableCachedFiles.delete(e.evicted[d]);
+    for (let h = 0; h < e.evicted.length; h++)
+      this.pageTableCachedFiles.delete(e.evicted[h]);
     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 d of this.pageTableFetchPriority) this.requestChunk(d, "priority");
+    for (const h of this.pageTableFetchPriority) this.requestChunk(h, "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 i = t.radTree;
-    if (!i) return;
+    const s = t.radTree;
+    if (!s) return;
     this.pageTableCachedFiles.add(e);
     const n = this.shBands > 0 ? t.shPacked : void 0;
     this.postToWorker(
@@ -2209,9 +2241,9 @@ class Y extends Ee {
         positions: t.positions,
         colors: t.colors,
         covariances: t.covariances,
-        childCount: i.childCount,
-        childStart: i.childStart,
-        size: i.size,
+        childCount: s.childCount,
+        childStart: s.childStart,
+        size: s.size,
         shBands: (n == null ? void 0 : n.bands) ?? 0,
         ...n ? { shPacked: n.packed, shRange: n.range } : {}
       },
@@ -2219,9 +2251,9 @@ class Y extends Ee {
         t.positions.buffer,
         t.colors.buffer,
         t.covariances.buffer,
-        i.childCount.buffer,
-        i.childStart.buffer,
-        i.size.buffer,
+        s.childCount.buffer,
+        s.childStart.buffer,
+        s.size.buffer,
         ...n ? [n.packed.buffer] : []
       ]
     );
@@ -2230,7 +2262,7 @@ class Y extends Ee {
    * 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 dt;
+    return ut;
   }
   /**
    * Whether this mesh may run its speculative background sweep. A mesh with no
@@ -2260,8 +2292,8 @@ class Y extends Ee {
     for (const t of this.fetching.values())
       t.kind === e && t.controller.abort();
   }
-  requestChunk(e, t, i) {
-    var l, c;
+  requestChunk(e, t, s) {
+    var r, 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;
@@ -2271,31 +2303,31 @@ class Y extends Ee {
       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 r = new AbortController();
-    this.fetching.set(e, { controller: r, kind: t, classicWant: i }), this.loader.load(a, {
+    if (this.fetchHandle && !((r = this.fetchScheduler) != null && r.tryAcquire(this.fetchHandle, t))) return;
+    const o = new AbortController();
+    this.fetching.set(e, { controller: o, kind: t, classicWant: s }), this.loader.load(a, {
       kind: this.scene.chunkKind,
-      signal: r.signal,
+      signal: o.signal,
       ...(c = this.scene.chunkOptions) == null ? void 0 : c[e]
-    }).then((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 d;
-      if (N(h)) return;
-      const f = (((d = this.retrying.get(e)) == null ? void 0 : d.attempts) ?? 0) + 1;
+    }).then((u) => {
+      var f, h;
+      this.disposed || (this.retrying.delete(e), (h = (f = this.scene.source).onChunkDecoded) == null || h.call(f, e, u), this.frontierWorker ? (this.forwardChunkToWorker(e, u), this.pendingWork = !0) : this.cacheChunk(e, u));
+    }).catch((u) => {
+      var h;
+      if (D(u)) return;
+      const f = (((h = this.retrying.get(e)) == null ? void 0 : h.attempts) ?? 0) + 1;
       if (f >= gt)
         this.retrying.delete(e), this.failedFiles.add(e), E(
           `StreamedSplatMesh: gave up on chunk #${e} (${a}) after ${f} attempts.`,
-          h
+          u
         );
       else {
         const g = pt * 2 ** (f - 1);
         this.retrying.set(e, { attempts: f, readyAt: performance.now() + g });
       }
     }).finally(() => {
-      var h;
-      this.fetching.delete(e), this.fetchHandle && ((h = this.fetchScheduler) == null || h.release(this.fetchHandle)), this.pendingWork = !0;
+      var u;
+      this.fetching.delete(e), this.fetchHandle && ((u = this.fetchScheduler) == null || u.release(this.fetchHandle)), this.pendingWork = !0;
     });
   }
   /**
@@ -2304,53 +2336,53 @@ class Y extends Ee {
    * of {@link cache} (this method, eviction, dispose's clear) maintains it.
    */
   cacheChunk(e, t) {
-    const i = this.cache.get(e);
-    i !== void 0 && (this.cacheBytesTotal -= i.bytes);
+    const s = this.cache.get(e);
+    s !== void 0 && (this.cacheBytesTotal -= s.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 i = [...this.cache.entries()].filter(
+    const s = [...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) {
+    for (const [n, a] of s) {
       if (t <= this.cpuCacheBytes) break;
       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(), 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);
+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(), M = new w.Vector3(), Se = new w.Vector2();
+function be(l) {
+  return Math.ceil(3 * Te(l) / 4);
 }
-function yt(o, s, e) {
-  const t = o.shPacked;
+function yt(l, i, e) {
+  const t = l.shPacked;
   return {
     count: e,
-    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),
+    positions: l.positions.subarray(i * 3, (i + e) * 3),
+    colors: l.colors.subarray(i * 4, (i + e) * 4),
+    covariances: l.covariances.subarray(i * 6, (i + e) * 6),
     ...t ? {
       shPacked: {
         ...t,
         packed: t.packed.subarray(
-          s * be(t.bands),
-          (s + e) * be(t.bands)
+          i * be(t.bands),
+          (i + e) * be(t.bands)
         )
       }
     } : {}
   };
 }
 const Ct = 1;
-class Tt {
-  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;
+class It {
+  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;
     if (!Number.isFinite(e) || e < 0)
       throw new RangeError("BudgetGovernor hysteresis must be a non-negative finite number.");
     this.hysteresis = e;
@@ -2360,8 +2392,8 @@ class Tt {
     return this.total;
   }
   /** Replaces the shared total and reallocates. */
-  setTotalBudget(s) {
-    const e = W(s);
+  setTotalBudget(i) {
+    const e = W(i);
     e !== this.total && (this.total = e, this.reallocate());
   }
   /** Number of registered members. */
@@ -2377,15 +2409,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(s, e = {}) {
-    if (this.entries.has(s))
+  register(i, e = {}) {
+    if (this.entries.has(i))
       throw new Error("BudgetGovernor: member is already registered.");
     const t = J(e.weight ?? 1);
-    this.entries.set(s, {
-      member: s,
+    this.entries.set(i, {
+      member: i,
       weight: t,
-      applied: s.budget,
-      restoreBudget: s.budget
+      applied: i.budget,
+      restoreBudget: i.budget
     }), this.reallocate();
   }
   /**
@@ -2393,17 +2425,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(s) {
-    const e = this.entries.get(s);
-    e !== void 0 && (this.entries.delete(s), e.member.setBudget(e.restoreBudget), this.reallocate());
+  unregister(i) {
+    const e = this.entries.get(i);
+    e !== void 0 && (this.entries.delete(i), 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(s, e) {
-    const t = this.entryOf(s), i = J(e);
-    i !== t.weight && (t.weight = i, this.reallocate());
+  setWeight(i, e) {
+    const t = this.entryOf(i), s = J(e);
+    s !== t.weight && (t.weight = s, this.reallocate());
   }
   /**
    * Writes several weights, then reallocates **once**.
@@ -2420,19 +2452,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(s) {
-    const e = [...s].map(
-      ([i, n]) => [this.entryOf(i), J(n)]
+  setWeights(i) {
+    const e = [...i].map(
+      ([s, n]) => [this.entryOf(s), J(n)]
     );
     let t = !1;
-    for (const [i, n] of e)
-      i.weight !== n && (i.weight = n, t = !0);
+    for (const [s, n] of e)
+      s.weight !== n && (s.weight = n, t = !0);
     t && this.reallocate();
   }
   /** The budget the governor last applied to a member, if registered. */
-  budgetOf(s) {
+  budgetOf(i) {
     var e;
-    return (e = this.entries.get(s)) == null ? void 0 : e.applied;
+    return (e = this.entries.get(i)) == null ? void 0 : e.applied;
   }
   /**
    * Recomputes and applies every member's share. Called automatically by all
@@ -2440,19 +2472,19 @@ class Tt {
    * outside the governor's view.
    */
   reallocate() {
-    let s = [];
+    let i = [];
     for (const t of this.entries.values())
-      t.weight === 0 ? this.applyTarget(t, Ct) : s.push(t);
+      t.weight === 0 ? this.applyTarget(t, Ct) : i.push(t);
     let e = this.total;
-    for (; s.length > 0; ) {
-      const t = s.reduce((a, r) => a + r.weight, 0), i = [];
+    for (; i.length > 0; ) {
+      const t = i.reduce((a, o) => a + o.weight, 0), s = [];
       let n = 0;
-      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);
+      for (const a of i) {
+        const o = Math.max(1, Math.floor(e * a.weight / t));
+        this.applyTarget(a, o) && (s.push(a), n += a.applied);
       }
-      if (i.length === 0) break;
-      e = Math.max(0, e - n), s = s.filter((a) => !i.includes(a));
+      if (s.length === 0) break;
+      e = Math.max(0, e - n), i = i.filter((a) => !s.includes(a));
     }
   }
   /**
@@ -2460,13 +2492,13 @@ class Tt {
    * The governor itself stays usable (dispose is just "unregister everyone").
    */
   dispose() {
-    for (const s of this.entries.values())
-      s.member.setBudget(s.restoreBudget);
+    for (const i of this.entries.values())
+      i.member.setBudget(i.restoreBudget);
     this.entries.clear();
   }
   /** The entry for a registered member, or a thrown error naming the problem. */
-  entryOf(s) {
-    const e = this.entries.get(s);
+  entryOf(i) {
+    const e = this.entries.get(i);
     if (e === void 0)
       throw new Error("BudgetGovernor: member is not registered.");
     return e;
@@ -2475,36 +2507,36 @@ 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(s, e) {
-    if (e > s.applied) {
-      if (e - s.applied <= this.hysteresis * s.applied) return !1;
-    } else if (e === s.applied)
+  applyTarget(i, e) {
+    if (e > i.applied) {
+      if (e - i.applied <= this.hysteresis * i.applied) return !1;
+    } else if (e === i.applied)
       return !1;
-    return s.applied = s.member.setBudget(e), s.applied < e;
+    return i.applied = i.member.setBudget(e), i.applied < e;
   }
 }
-function J(o) {
-  if (!Number.isFinite(o) || o < 0)
+function J(l) {
+  if (!Number.isFinite(l) || l < 0)
     throw new RangeError(
       "BudgetGovernor member weight must be a non-negative finite number (0 suspends the member)."
     );
-  return o;
+  return l;
 }
 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);
+  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);
     /** Set by membership/priority changes: the next update ignores both damps. */
-    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)
+    d(this, "forceNext", !0);
+    if (this.budgetGovernor = i.governor ?? new It(i), this.minIntervalMs = G(i.minIntervalMs ?? 250, "minIntervalMs"), this.weightDeadband = G(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)
       throw new RangeError("CameraBudgetGovernor maxWeight must be >= minWeight.");
   }
   /** The governor this drives; use it for fixed-weight members and diagnostics. */
@@ -2516,8 +2548,8 @@ class zt {
     return this.budgetGovernor.totalBudget;
   }
   /** Replaces the shared total (e.g. the presenting budget on `sessionstart`). */
-  setTotalBudget(s) {
-    this.budgetGovernor.setTotalBudget(s);
+  setTotalBudget(i) {
+    this.budgetGovernor.setTotalBudget(i);
   }
   /** Number of camera-weighted members. */
   get size() {
@@ -2530,18 +2562,18 @@ class zt {
    * @throws {Error} if the member is already registered here.
    * @throws {RangeError} if `priority` or `fixedWeight` is invalid.
    */
-  register(s, e = {}) {
-    if (this.entries.has(s))
+  register(i, e = {}) {
+    if (this.entries.has(i))
       throw new Error("CameraBudgetGovernor: member is already registered.");
-    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;
+    const t = G(e.priority ?? 1, "priority"), s = e.fixedWeight === void 0 ? void 0 : G(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;
   }
   /**
    * 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(s) {
-    this.entries.delete(s) && (this.budgetGovernor.unregister(s), this.forceNext = !0);
+  unregister(i) {
+    this.entries.delete(i) && (this.budgetGovernor.unregister(i), this.forceNext = !0);
   }
   /**
    * Changes a member's priority tier. Takes effect on the next {@link update},
@@ -2551,12 +2583,12 @@ class zt {
    * @throws {Error} if the member is not registered here.
    * @throws {RangeError} if `priority` is negative or not finite.
    */
-  setPriority(s, e) {
-    const t = this.entries.get(s);
+  setPriority(i, e) {
+    const t = this.entries.get(i);
     if (t === void 0)
       throw new Error("CameraBudgetGovernor: member is not registered.");
-    const i = D(e, "priority");
-    i !== t.priority && (t.priority = i, this.forceNext = !0);
+    const s = G(e, "priority");
+    s !== t.priority && (t.priority = s, this.forceNext = !0);
   }
   /**
    * Recomputes every member's weight from the camera and applies them in one
@@ -2573,33 +2605,33 @@ class zt {
    * @param now - Timestamp in ms on the `performance.now` clock; defaults to it.
    * @returns whether weights were reapplied.
    */
-  update(s, e = performance.now()) {
+  update(i, e = performance.now()) {
     if (this.entries.size === 0) return !1;
     const t = this.forceNext;
     if (!t && e - this.lastUpdateAt < this.minIntervalMs) return !1;
-    s.updateMatrixWorld(), s.getWorldPosition(we), ye.multiplyMatrices(s.projectionMatrix, s.matrixWorldInverse), Ce.setFromProjectionMatrix(ye);
-    const i = [];
+    i.updateMatrixWorld(), i.getWorldPosition(we), ye.multiplyMatrices(i.projectionMatrix, i.matrixWorldInverse), Ce.setFromProjectionMatrix(ye);
+    const s = [];
     let n = !1;
     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);
+      const o = this.weightFor(a);
+      s.push([a.member, o]), !n && this.isSignificant(a.applied, o) && (n = !0);
     }
     if (!t && !n) return !1;
-    this.budgetGovernor.setWeights(i);
-    for (const [a, r] of i) {
-      const l = this.entries.get(a);
-      l !== void 0 && (l.applied = r);
+    this.budgetGovernor.setWeights(s);
+    for (const [a, o] of s) {
+      const r = this.entries.get(a);
+      r !== void 0 && (r.applied = o);
     }
     return this.lastUpdateAt = e, this.forceNext = !1, !0;
   }
   /** The weight currently written for a member, if registered here. */
-  weightOf(s) {
+  weightOf(i) {
     var e;
-    return (e = this.entries.get(s)) == null ? void 0 : e.applied;
+    return (e = this.entries.get(i)) == null ? void 0 : e.applied;
   }
   /** The budget the underlying governor last applied to a member. */
-  budgetOf(s) {
-    return this.budgetGovernor.budgetOf(s);
+  budgetOf(i) {
+    return this.budgetGovernor.budgetOf(i);
   }
   /**
    * Unregisters every member, restoring the budget each had when it joined.
@@ -2607,7 +2639,7 @@ class zt {
    * any members the host registered on it directly.
    */
   dispose() {
-    for (const s of [...this.entries.keys()]) this.budgetGovernor.unregister(s);
+    for (const i of [...this.entries.keys()]) this.budgetGovernor.unregister(i);
     this.entries.clear(), this.lastUpdateAt = -1 / 0, this.forceNext = !0;
   }
   /**
@@ -2621,49 +2653,49 @@ class zt {
    * distant center, and is floored so a camera inside the bounds saturates at
    * `maxWeight` rather than dividing by zero.
    */
-  weightFor(s) {
-    if (s.fixedWeight !== void 0) return s.fixedWeight;
-    const { member: e, priority: t } = s;
+  weightFor(i) {
+    if (i.fixedWeight !== void 0) return i.fixedWeight;
+    const { member: e, priority: t } = i;
     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(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;
+    const s = z.radius;
+    if (!(s > 0)) return t * this.minWeight;
+    const n = z.center.distanceTo(we) - s, a = Math.max(n, s * 1e-3, 1e-6), o = Tt((s / a) ** this.falloff, this.minWeight, this.maxWeight);
+    if (!Number.isFinite(o)) return t * this.minWeight;
+    const r = Ce.intersectsSphere(z) ? 1 : this.offScreenWeight;
+    return t * o * r;
   }
   /** Whether a weight moved enough to be worth a reallocation. */
-  isSignificant(s, e) {
-    return s === 0 || e === 0 ? s !== e : Math.abs(e - s) > this.weightDeadband * s;
+  isSignificant(i, e) {
+    return i === 0 || e === 0 ? i !== e : Math.abs(e - i) > this.weightDeadband * i;
   }
 }
-function It(o, s, e) {
-  return Math.min(e, Math.max(s, o));
+function Tt(l, i, e) {
+  return Math.min(e, Math.max(i, l));
 }
-function D(o, s) {
-  if (!Number.isFinite(o) || o < 0)
-    throw new RangeError(`CameraBudgetGovernor ${s} must be a non-negative finite number.`);
-  return o;
+function G(l, i) {
+  if (!Number.isFinite(l) || l < 0)
+    throw new RangeError(`CameraBudgetGovernor ${i} must be a non-negative finite number.`);
+  return l;
 }
-function U(o, s) {
-  if (!Number.isFinite(o) || o <= 0)
-    throw new RangeError(`CameraBudgetGovernor ${s} must be a positive finite number.`);
-  return o;
+function U(l, i) {
+  if (!Number.isFinite(l) || l <= 0)
+    throw new RangeError(`CameraBudgetGovernor ${i} must be a positive finite number.`);
+  return l;
 }
-const Rt = 16, Mt = 1;
+const Rt = 16, Ft = 1;
 class Ut {
-  constructor(s = {}) {
-    u(this, "entries", /* @__PURE__ */ new Set());
-    u(this, "maxGlobalInflight");
-    u(this, "perMeshFloor");
-    u(this, "inflightCount", 0);
-    u(this, "disposed", !1);
+  constructor(i = {}) {
+    d(this, "entries", /* @__PURE__ */ new Set());
+    d(this, "maxGlobalInflight");
+    d(this, "perMeshFloor");
+    d(this, "inflightCount", 0);
+    d(this, "disposed", !1);
     this.maxGlobalInflight = Math.max(
       1,
-      Math.floor(s.maxGlobalInflight ?? Rt)
-    ), this.perMeshFloor = Math.max(0, Math.floor(s.perMeshFloor ?? Mt));
+      Math.floor(i.maxGlobalInflight ?? Rt)
+    ), this.perMeshFloor = Math.max(0, Math.floor(i.perMeshFloor ?? Ft));
   }
   /** Total slots granted and not yet released. */
   get inflight() {
@@ -2673,16 +2705,16 @@ class Ut {
   get clientCount() {
     return this.entries.size;
   }
-  register(s) {
-    const e = { client: s, held: 0, demanding: !1, live: !0 };
+  register(i) {
+    const e = { client: i, 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(s) {
-    const e = s;
+  unregister(i) {
+    const e = i;
     this.entries.delete(e) && (e.live = !1, e.held > 0 && (this.inflightCount -= e.held, e.held = 0, this.wake()));
   }
   /**
@@ -2692,19 +2724,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(s, e) {
-    const t = s;
+  tryAcquire(i, e) {
+    const t = i;
     if (this.disposed || !t.live) return !1;
-    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);
+    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);
   }
   /**
    * 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(s) {
-    const e = s;
+  release(i) {
+    const e = i;
     e.held <= 0 || (e.held--, this.inflightCount--, this.wake());
   }
   /**
@@ -2717,8 +2749,8 @@ class Ut {
    */
   weightsChanged() {
     if (!this.disposed) {
-      for (const s of this.entries)
-        s.held > 0 && H(s.client.weight()) <= 0 && s.client.shedFetches("sweep");
+      for (const i of this.entries)
+        i.held > 0 && H(i.client.weight()) <= 0 && i.client.shedFetches("sweep");
       this.wake();
     }
   }
@@ -2729,8 +2761,8 @@ class Ut {
    */
   dispose() {
     this.disposed = !0;
-    for (const s of this.entries)
-      s.live = !1, s.held = 0, s.demanding = !1;
+    for (const i of this.entries)
+      i.live = !1, i.held = 0, i.demanding = !1;
     this.entries.clear(), this.inflightCount = 0;
   }
   /**
@@ -2750,47 +2782,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(s, e) {
-    let t = 0, i = 0;
-    for (const l of this.entries) {
-      const c = l === s ? e : H(l.client.weight());
-      l !== s && c <= 0 && l.held === 0 && !l.demanding || (t++, i += c);
+  shareFor(i, e) {
+    let t = 0, s = 0;
+    for (const r of this.entries) {
+      const c = r === i ? e : H(r.client.weight());
+      r !== i && c <= 0 && r.held === 0 && !r.demanding || (t++, s += c);
     }
     if (t <= 1) return this.maxGlobalInflight;
-    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));
+    const n = s > 0 ? this.maxGlobalInflight * e / s : this.maxGlobalInflight / t, a = Math.max(1, this.perMeshFloor, Math.round(n)), o = Math.max(1, this.perMeshFloor) * (t - 1);
+    return Math.max(1, Math.min(a, this.maxGlobalInflight - o));
   }
   /** Pokes the heaviest mesh that was denied since its last grant. */
   wake() {
     if (this.disposed || this.inflightCount >= this.maxGlobalInflight) return;
-    let s = null, e = -1 / 0;
+    let i = null, e = -1 / 0;
     for (const t of this.entries) {
       if (!t.demanding) continue;
-      const i = H(t.client.weight());
-      i > e && (s = t, e = i);
+      const s = H(t.client.weight());
+      s > e && (i = t, e = s);
     }
-    s && (s.demanding = !1, s.client.onSlotAvailable());
+    i && (i.demanding = !1, i.client.onSlotAvailable());
   }
 }
-function H(o) {
-  return Number.isFinite(o) && o > 0 ? o : 0;
+function H(l) {
+  return Number.isFinite(l) && l > 0 ? l : 0;
 }
-const Ft = 32 * 1024 * 1024, Bt = 250, Pt = 0.15;
+const Mt = 32 * 1024 * 1024, Bt = 250, Pt = 0.15;
 class Ht {
-  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)
+  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)
       throw new RangeError("Chunk cache totalBytes must be a positive finite number.");
-    this.totalBytesValue = Math.floor(s.totalBytes), this.perMeshFloorBytes = Math.max(
+    this.totalBytesValue = Math.floor(i.totalBytes), this.perMeshFloorBytes = Math.max(
       0,
-      Math.floor(s.perMeshFloorBytes ?? Ft)
-    ), this.minIntervalMs = Math.max(0, s.minIntervalMs ?? Bt), this.deadband = Math.max(0, s.deadband ?? Pt);
+      Math.floor(i.perMeshFloorBytes ?? Mt)
+    ), this.minIntervalMs = Math.max(0, i.minIntervalMs ?? Bt), this.deadband = Math.max(0, i.deadband ?? Pt);
   }
   /** Bytes shared across every registered mesh. */
   get totalBytes() {
@@ -2800,10 +2832,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(s) {
-    if (!Number.isFinite(s) || s <= 0)
+  setTotalBytes(i) {
+    if (!Number.isFinite(i) || i <= 0)
       throw new RangeError("Chunk cache totalBytes must be a positive finite number.");
-    const e = Math.floor(s);
+    const e = Math.floor(i);
     e !== this.totalBytesValue && (this.totalBytesValue = e, this.allocate());
   }
   /** Meshes currently registered. */
@@ -2814,18 +2846,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(s) {
-    const e = { client: s, allowance: 0, live: !0 };
+  register(i) {
+    const e = { client: i, 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(s) {
-    const e = s;
+  unregister(i) {
+    const e = i;
     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(s) {
-    const e = s;
+  allowanceFor(i) {
+    const e = i;
     return e.live ? e.allowance : 0;
   }
   /**
@@ -2835,8 +2867,8 @@ class Ht {
    *
    * Rate-limited and dead-banded; calling it every frame is the intended use.
    */
-  weightsChanged(s = Date.now()) {
-    this.disposed || s - this.lastAllocationMs < this.minIntervalMs || (this.lastAllocationMs = s, this.allocate());
+  weightsChanged(i = Date.now()) {
+    this.disposed || i - this.lastAllocationMs < this.minIntervalMs || (this.lastAllocationMs = i, this.allocate());
   }
   /**
    * Releases every registration. Meshes are not disposed - the budget is shared
@@ -2845,8 +2877,8 @@ class Ht {
    */
   dispose() {
     this.disposed = !0;
-    for (const s of this.entries)
-      s.live = !1, s.allowance = 0;
+    for (const i of this.entries)
+      i.live = !1, i.allowance = 0;
     this.entries.clear();
   }
   /**
@@ -2860,44 +2892,44 @@ class Ht {
    * silently overcommitting, because a budget that can be exceeded by
    * registering more meshes is the bug this class exists to fix.
    */
-  allocate(s = {}) {
+  allocate(i = {}) {
     if (this.disposed) return;
     const e = [...this.entries];
     if (e.length === 0) return;
-    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 d of a) h += Te(d.client.weight());
+    const t = this.totalBytesValue, s = Math.min(this.perMeshFloorBytes, Math.floor(t / e.length)), n = /* @__PURE__ */ new Map(), a = new Set(e);
+    let o = t;
+    for (let r = 0; r <= e.length && a.size > 0; r++) {
+      const c = Math.max(0, o - s * a.size);
+      let u = 0;
+      for (const h of a) u += Ie(h.client.weight());
       const f = [];
-      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);
+      for (const h of a) {
+        const g = Ie(h.client.weight()), v = u > 0 ? c * g / u : c / a.size, m = kt(h.client.ceilingBytes), b = Math.floor(s + v);
+        b >= m ? (n.set(h, m), f.push(h)) : n.set(h, b);
       }
       if (f.length === 0) break;
-      for (const d of f)
-        a.delete(d), r -= n.get(d) ?? 0;
-      r = Math.max(0, r);
+      for (const h of f)
+        a.delete(h), o -= n.get(h) ?? 0;
+      o = Math.max(0, o);
     }
-    for (const l of e) {
-      const c = n.get(l) ?? 0, h = l.allowance;
-      l.allowance = c, l !== s.silentFor && (!s.force && !this.movedEnough(h, c) || h !== c && l.client.onAllowanceChanged(c));
+    for (const r of e) {
+      const c = n.get(r) ?? 0, u = r.allowance;
+      r.allowance = c, r !== i.silentFor && (!i.force && !this.movedEnough(u, c) || u !== c && r.client.onAllowanceChanged(c));
     }
   }
   /** Suppresses reposts for changes too small to alter any mesh's behaviour. */
-  movedEnough(s, e) {
-    return s === e ? !1 : s === 0 || e === 0 ? !0 : Math.abs(e - s) / s >= this.deadband;
+  movedEnough(i, e) {
+    return i === e ? !1 : i === 0 || e === 0 ? !0 : Math.abs(e - i) / i >= this.deadband;
   }
 }
-function Te(o) {
-  return Number.isFinite(o) && o > 0 ? o : 0;
+function Ie(l) {
+  return Number.isFinite(l) && l > 0 ? l : 0;
 }
-function kt(o) {
-  return Number.isFinite(o) && o > 0 ? Math.floor(o) : Number.MAX_SAFE_INTEGER;
+function kt(l) {
+  return Number.isFinite(l) && l > 0 ? Math.floor(l) : Number.MAX_SAFE_INTEGER;
 }
 export {
-  Tt as BudgetGovernor,
+  It as BudgetGovernor,
   zt as CameraBudgetGovernor,
   Ht as ChunkCacheBudget,
   Ut as ChunkFetchScheduler,
@@ -2905,7 +2937,7 @@ export {
   Y as StreamedSplatMesh,
   ot as createLocalDataset,
   nt as httpDatasetSource,
-  N as isAbortError,
+  D as isAbortError,
   Be as resolveCpuCacheBytes
 };
 //# sourceMappingURL=streaming.js.map