@voluma/vlam 0.2.4 → 0.3.2

package/dist/streaming.js

@@ -0,0 +1,2911 @@
+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);
+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 { y as Le } from "./relighting-Tiwep8yd.js";
+import { C as Ve } from "./chunk-loader-DlNwggfG.js";
+import { s as Ie } from "./sh-pack-D5wAe5gg.js";
+import { w as 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],
+    removes: [],
+    leafStart: s.leafStart,
+    leafEnd: s.leafEnd,
+    addCount: s.count
+  })).sort((s, e) => s.leafStart - e.leafStart);
+}
+function Oe(o, s) {
+  const e = [...o, ...s.map(([, n]) => n.run)];
+  if (e.length > 0 && e.every((n) => n.coverageGroup !== void 0)) {
+    const n = /* @__PURE__ */ new Map(), a = (l) => {
+      let c = n.get(l);
+      return c || (c = { adds: [], removes: [] }, n.set(l, 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);
+        let m = c.get(v);
+        return m || (m = { adds: [], removes: [], leafStart: d, 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 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);
+      }
+      r.push(...c.values());
+    }
+    return r.sort((l, c) => l.leafStart - c.leafStart);
+  }
+  const t = [
+    ...o.map((n) => ({
+      start: n.leafStart,
+      end: n.leafEnd,
+      add: n,
+      remove: void 0
+    })),
+    ...s.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 = [];
+  for (const n of t) {
+    const a = i[i.length - 1];
+    (!a || n.start >= a.leafEnd) && i.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);
+  }
+  return i;
+}
+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 ze(o) {
+  return o.length > 0 && o.every(
+    (s) => [...s.adds, ...s.removes.map(([, e]) => e.run)].every(
+      (e) => e.coverageGroup !== void 0
+    )
+  );
+}
+function Ue(o, s) {
+  const e = (n) => {
+    const a = [...n.adds, ...n.removes.map(([, r]) => r.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))
+    };
+  }, t = e(o), i = e(s);
+  return t.removeOnly - i.removeOnly || t.view - i.view || t.finest - i.finest || t.screen - i.screen || t.distance - i.distance || o.leafStart - s.leafStart;
+}
+function re(o) {
+  switch (o) {
+    case "environment":
+      return -1;
+    case "finest-target":
+      return 0;
+    case "coverage":
+      return 1;
+    case "target":
+      return 2;
+    default:
+      return 3;
+  }
+}
+function He(o) {
+  return o === "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 $e(o, s = 10, e = !1) {
+  const t = te(s), i = /* @__PURE__ */ new Map();
+  for (const [n, a] of o) {
+    if (a.phase === "environment") continue;
+    const r = G(a, n), l = i.get(r);
+    if (!l) {
+      i.set(r, {
+        distance: a.distance,
+        count: 1,
+        inView: a.inView,
+        screenImportance: a.screenImportance,
+        finest: a.phase === "finest-target"
+      });
+      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++;
+  }
+  for (const [n, a] of o) {
+    if (a.phase === "environment") {
+      a.kind = "priority", a.groupDistance = 0, a.groupPending = 1, a.groupInView = !0, a.groupScreenImportance = Number.NEGATIVE_INFINITY, a.groupFinest = !0, a.groupId = "environment", a.groupClass = 0;
+      continue;
+    }
+    const 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;
+  }
+}
+function te(o, s = 2) {
+  return o;
+}
+function Ye(o) {
+  return o.adds.some((s) => s.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 je(o, s, e = 2) {
+  const t = o.distance ?? Number.POSITIVE_INFINITY;
+  return o.inView === !1 && t > te(s) ? "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
+    );
+    o.set(s, {
+      kind: c,
+      phase: e,
+      distance: i,
+      level: n,
+      inView: a,
+      coverageGroup: r,
+      leafStart: t.leafStart,
+      leafEnd: t.leafEnd,
+      screenImportance: l,
+      groupDistance: i,
+      groupPending: 1,
+      groupInView: a,
+      groupScreenImportance: l,
+      groupFinest: e === "finest-target",
+      groupId: v,
+      // Provisional; finalized in stampClassicFetchGroups().
+      groupClass: 2
+    });
+    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, {
+    kind: c,
+    phase: e,
+    distance: i,
+    level: n,
+    inView: a || h.inView,
+    coverageGroup: r >= 0 ? r : h.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
+  });
+}
+function X(o, s, e, t) {
+  const i = o.groupDistance ?? o.distance, n = s.groupDistance ?? s.distance, a = o.groupPending ?? 1, r = s.groupPending ?? 1, l = o.groupId ?? G(o, e), c = s.groupId ?? G(s, t), h = o.groupClass ?? (o.inView ? 0 : 2), f = s.groupClass ?? (s.inView ? 0 : 2), d = o.groupScreenImportance ?? o.screenImportance, g = s.groupScreenImportance ?? s.screenImportance, v = o.groupFinest ? 0 : 1, m = s.groupFinest ? 0 : 1, b = (y) => y === "coverage" ? 0 : y === "background" ? 2 : 1, T = o.phase === "environment" ? 0 : 1, I = s.phase === "environment" ? 0 : 1;
+  return T - I || h - f || v - m || d - g || i - n || r - a || (l < c ? -1 : l > c ? 1 : 0) || b(o.phase) - b(s.phase) || o.level - s.level || e - t;
+}
+function K(o, s, e) {
+  if (s < 0 || e < 0 || s + e > o.count)
+    throw new Error(
+      `Splat range [${s}, ${s + e}) exceeds its chunk's ${o.count} splats; the manifest and chunk data disagree.`
+    );
+  const t = o.shPacked;
+  return {
+    count: e,
+    positions: o.positions.subarray(s * 3, (s + e) * 3),
+    colors: o.colors.subarray(s * 4, (s + e) * 4),
+    covariances: o.covariances.subarray(s * 6, (s + e) * 6),
+    // Per-splat SH is splat-major, so it slices like everything else. Palette
+    // shN (`chunk.sh`) is deliberately not carried: its labels index a
+    // per-file codebook the shared pool has no way to hold.
+    ...t ? {
+      shPacked: {
+        ...t,
+        packed: t.packed.subarray(
+          s * le(t.bands),
+          (s + e) * le(t.bands)
+        )
+      }
+    } : {},
+    // Per-splat frontier `parent_size` (foveated `.rad`) slices splat-major like
+    // the rest; uploaded into `covarianceB.w` by the pool.
+    ...o.frontierParent ? { frontierParent: o.frontierParent.subarray(s, s + e) } : {}
+  };
+}
+function le(o) {
+  return o === 1 ? 3 : o === 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
+  // base 32); omitting it would let the CPU cache run ~3x over its cap.
+  (((s = o.shPacked) == null ? void 0 : s.packed.byteLength) ?? 0);
+}
+function Ke(o) {
+  const s = o.reason;
+  return s instanceof Error ? s : new DOMException("Aborted", "AbortError");
+}
+function Qe(o) {
+  const s = o ?? Ne;
+  if (!Number.isInteger(s) || s <= 0)
+    throw new RangeError("StreamedSplatMesh maxSplatsPerSwap must be a positive integer.");
+  return s;
+}
+function ce(o) {
+  const s = o ?? 1;
+  if (!Number.isFinite(s) || s <= 0)
+    throw new RangeError("StreamedSplatMesh lodScale must be a positive finite number.");
+  return s;
+}
+function Je() {
+  return Be();
+}
+function Ze(o, s) {
+  const e = o;
+  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"))
+    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))
+    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)
+      throw new Error("Streamed SOG manifest tree contains a malformed node.");
+    if (l.children) {
+      if (!Array.isArray(l.children) || l.children.length !== 2)
+        throw new Error("Streamed SOG manifest tree node must have exactly two children.");
+      r.push(l.children[1], l.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);
+    }
+    n.push({ bounds: he(l.bound), lods: c });
+  }
+  return {
+    leaves: n,
+    chunkUrls: i,
+    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)
+    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}).`
+    );
+}
+function he(o) {
+  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])
+  );
+}
+function tt(o, s, e, t = 0) {
+  const i = Ze(o, s), n = t >= 1 ? t : void 0, a = i.chunkUrls.map((r, l) => {
+    var f;
+    const c = (f = i.chunkDirectories) == null ? void 0 : f[l], h = c ? s.directoryFiles(c) : null;
+    if (!(!h && !n))
+      return {
+        format: "sog",
+        ...h ? { files: h } : {},
+        ...n ? { sog: { packShBands: n } } : {}
+      };
+  });
+  return {
+    source: new We(i, e),
+    chunkUrls: i.chunkUrls,
+    ...a.some(Boolean) ? { chunkOptions: a } : {},
+    ...n ? { shBands: n } : {},
+    chunkKind: "directory",
+    // Streamed SOG chunks are unbundled directories
+    bounds: i.bounds,
+    pinnedFiles: it(i),
+    maxResidentSplats: i.counts[0] ?? e.budget,
+    minimumCoverageSplats: st(i)
+  };
+}
+function st(o) {
+  let s = 0;
+  for (const e of o.leaves)
+    for (let t = e.lods.length - 1; t >= 0; t--) {
+      const i = e.lods[t];
+      if (i) {
+        s += i.count;
+        break;
+      }
+    }
+  return Math.max(1, s);
+}
+function it(o) {
+  const s = /* @__PURE__ */ new Set();
+  for (const e of o.leaves)
+    for (let t = e.lods.length - 1; t >= 0; t--) {
+      const i = e.lods[t];
+      if (i) {
+        s.add(i.file);
+        break;
+      }
+    }
+  return s;
+}
+function nt(o, s) {
+  return {
+    manifestUrl: o,
+    resolve: (e) => new URL(e, o).href,
+    size: (e) => at(new URL(e, o).href, s),
+    directoryFiles: () => null,
+    dispose: () => {
+    }
+  };
+}
+async function at(o, s) {
+  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));
+    } 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" }
+    });
+    if (await de(t), t.status !== 206) return null;
+    const i = (e = t.headers.get("content-range")) == null ? void 0 : e.split("/")[1];
+    return i === void 0 || i === "*" ? null : ue(Number(i));
+  } catch {
+    return null;
+  }
+}
+async function de(o) {
+  var s;
+  try {
+    await ((s = o.body) == null ? void 0 : s.cancel());
+  } catch {
+  }
+}
+function ue(o) {
+  return Number.isSafeInteger(o) && o >= 0 ? o : null;
+}
+const rt = [
+  { test: (o) => o.endsWith(".lcc2"), format: "lcc2" },
+  { test: (o) => o.endsWith(".lcc"), format: "lcc" },
+  // The `.rad` header of a `--rad-chunked` set; `.radc` chunk files are not
+  // 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" }
+];
+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 });
+  }
+  if (s.length === 0)
+    throw new q(
+      "That folder has no streamed-scene manifest in it (expected a .lcc, .lcc2 or lod-meta.json file).",
+      { phase: "manifest", url: "local-folder", retryable: !1 }
+    );
+  if (s.length > 1) {
+    const r = s.map((l) => $(l.path)).join(", ");
+    throw new q(
+      `That folder holds more than one scene manifest (${r}) - 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);
+    if (!c) return null;
+    const h = URL.createObjectURL(c);
+    return i.set(r, h), h;
+  };
+  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);
+    },
+    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);
+      }
+      return Object.keys(c).length > 0 ? c : null;
+    },
+    dispose: () => {
+      for (const r of i.values()) URL.revokeObjectURL(r);
+      i.clear();
+    }
+  }, format: e.format, name: $(e.path) };
+}
+function Q(o) {
+  return o.replace(/^\.?\//, "");
+}
+function $(o) {
+  return o.slice(o.lastIndexOf("/") + 1);
+}
+function Re(o) {
+  return o.split("/").length - 1;
+}
+function lt(o, s) {
+  let e = 1 / 0;
+  for (const t of o.keys())
+    s.test($(t).toLowerCase()) && (e = Math.min(e, Re(t)));
+  return e;
+}
+const fe = {
+  coneFov0: 90,
+  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;
+}
+class Y extends Ee {
+  constructor(e, t, i, n, a, r = !1) {
+    var d, g, v;
+    super({ capacity: i }, n);
+    u(this, "scene");
+    u(this, "loader", new Ve());
+    /**
+     * Cap the *classic* (non-page-table) chunk cache evicts against.
+     *
+     * Mutable because a shared {@link ChunkCacheBudget} re-splits it as the camera
+     * 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");
+    /** Spark's per-mesh `lodScale`; divides the page-table cut limit. */
+    u(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");
+    /** 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());
+    /** Running byte total of {@link cache}; maintained by {@link cacheChunk}, eviction and dispose. */
+    u(this, "cacheBytesTotal", 0);
+    /** In-flight chunk fetches. The kind is kept so a weight change can shed the
+     * speculative ones without touching the detail that is actually on screen. */
+    u(this, "fetching", /* @__PURE__ */ new Map());
+    /** This mesh's camera-projected share of the scene's fetch bandwidth. */
+    u(this, "fetchWeight");
+    /** Scene-wide fetch arbitration, when the host shares one; see `requestChunk`. */
+    u(this, "fetchScheduler");
+    u(this, "fetchHandle");
+    /**
+     * Blob-URL dataset from {@link loadLocal}, owned by this mesh so its object
+     * URLs are revoked on {@link dispose} rather than leaking for the document's
+     * lifetime. Undefined for every network-loaded mesh.
+     */
+    u(this, "localSource");
+    /** Scene-wide chunk-cache ceiling, when the host shares one. */
+    u(this, "cacheBudget");
+    u(this, "cacheBudgetHandle");
+    /**
+     * The cap this mesh's frontier worker is currently evicting against.
+     *
+     * Mirrored on the main thread so `applyCacheAllowance` can skip no-op posts
+     * and so `fetchCounts.cacheLimitBytes` stays truthful between plans.
+     */
+    u(this, "cacheLimitBytes", 0);
+    u(this, "resident", /* @__PURE__ */ new Map());
+    /** Replacement runs hidden while their pool data is uploaded in bounded segments. */
+    u(this, "staged", /* @__PURE__ */ new Map());
+    /** Files awaiting a backoff retry after a transient fetch/decode error. */
+    u(this, "retrying", /* @__PURE__ */ new Map());
+    /** Files given up on after {@link MAX_CHUNK_ATTEMPTS} failures. */
+    u(this, "failedFiles", /* @__PURE__ */ new Set());
+    /**
+     * When true, each resident run writes its LOD `level` into the `lodLevel`
+     * float channel for false-color debug modifiers.
+     */
+    u(this, "lodLevelDebug", !1);
+    u(this, "lodLevelChannelReady", !1);
+    u(this, "lodLevelScratch");
+    /** Desired-but-not-resident files this tick; protected from cache eviction. */
+    u(this, "neededFiles", /* @__PURE__ */ new Set());
+    /** Non-null in `foveationMode: 'page-table'`: the worker that owns the chunk
+     * cache + traversal + pager off the main thread, and the always-active slab it
+     * pages the returned frontier into. */
+    u(this, "frontierWorker");
+    /**
+     * The frontier's slots, as a list of equally sized pages rather than one
+     * contiguous run.
+     *
+     * Slot `i` lives in page `i / slabPageSplats` at offset `i %
+     * slabPageSplats`. The pager only ever addresses slots, so where those
+     * pages sit in the pool is the mesh's business - which is what lets a mesh
+     * hold non-contiguous storage, and ultimately lets several meshes interleave
+     * in one pool instead of each reserving its whole ceiling as one block.
+     * (Spark's pager does the same thing one level down, binding fixed pages to
+     * `(source, chunk)` pairs.)
+     */
+    u(this, "slabPages", []);
+    /** Most slots the slab may ever hold - the construction capacity. */
+    u(this, "slabCeiling", 0);
+    /** Slot count the worker's pager was last told about. */
+    u(this, "pagerSlots", 0);
+    /** Consecutive ticks the wave gate has held retirements back. */
+    u(this, "retireHeldTicks", 0);
+    /** Backing store for {@link planTimings}. */
+    u(this, "planTimingsValue", {
+      applyMs: 0,
+      worstApplyMs: 0,
+      writeMs: 0,
+      residentMs: 0,
+      moves: 0,
+      appends: 0,
+      worstSplats: 0
+    });
+    /**
+     * Backing store for {@link fetchCounts}. Lifetime totals, because the question
+     * 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", {
+      priority: 0,
+      base: 0,
+      sweep: 0,
+      evicted: 0,
+      uncovered: 0,
+      retiredEarly: 0,
+      cacheFull: !1,
+      cacheBytes: 0,
+      cacheLimitBytes: 0
+    });
+    /**
+     * The screen-radius band the scene asked for, kept so the band can be scaled
+     * 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);
+    /**
+     * 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);
+    /** Target drawn-splat count for the page-table frontier; see the constructor. */
+    u(this, "pageTableDrawBudget", 0);
+    /** The unclamped draw target (`foveationDrawBudget` or the default), kept so
+     * `setBudget` can re-derive the effective draw budget when the pool budget
+     * moves (e.g. under a `BudgetGovernor`). */
+    u(this, "pageTableDrawTarget", 0);
+    /** Whether {@link pageTableDrawTarget} came from an explicit
+     * `foveationDrawBudget` - a caller-chosen hard cap worth warning about when a
+     * governed budget outgrows it, rather than the library's own default. */
+    u(this, "pageTableDrawTargetExplicit", !1);
+    /** Last frontier's drawn (non-degenerate) splat count - the true on-screen size
+     * in `page-table` mode, where the slab is fully "active" but mostly degenerate. */
+    u(this, "pageTableDrawn", 0);
+    u(this, "frontierConverged", !0);
+    u(this, "pendingFrontierSplats", 0);
+    u(this, "staleResidentSplats", 0);
+    u(this, "lastPlanAppends", 0);
+    u(this, "lastPlanMoves", 0);
+    u(this, "lastPlanGeneration", 0);
+    u(this, "lastPlanBudget", 0);
+    u(this, "lastPlanCamera", null);
+    u(this, "firstFrontierCamera", null);
+    /** Monotonic reschedule id; a stale plan (superseded by a newer request) is
+     * dropped. `pageTableInFlight` coalesces to one outstanding traversal. */
+    u(this, "pageTableSeq", 0);
+    u(this, "pageTableInFlight", !1);
+    u(this, "pageTableDisposed", !1);
+    /** Files whose data has been forwarded to the worker (so we don't refetch). */
+    u(this, "pageTableCachedFiles", /* @__PURE__ */ new Set());
+    /** Chunks the last frontier wanted but did not have, biggest-on-screen first.
+     * These outrank the background sweep - they are the detail actually on screen. */
+    u(this, "pageTableFetchPriority", []);
+    /** Frontier-cut target node size (px) and foveation ramp; see `frontierView`. */
+    u(this, "pageTableTargetPx", ie);
+    u(this, "pageTableFoveation", fe);
+    /** Drawing-buffer height, sampled in `update` so `reschedule` can derive the
+     * cut limit the same way the material does (`targetPx / focalY`). */
+    u(this, "pageTableViewportY", 0);
+    /** Frontier cut on foveated `size / distance`. Re-derived each reschedule once
+     * the drawing buffer is known; the initial value only covers the first frame. */
+    u(this, "pageTableLimit", 0.02);
+    /**
+     * Whether the worker's cache is sitting at its cap: sweeping past that point
+     * only evicts what the frontier is using.
+     *
+     * Re-derived from every plan rather than latched. It used to latch on the
+     * first eviction, which was safe only while the cap was sized to the capture
+     * and evictions therefore meant "this will never fit". Under a scene-wide
+     * {@link ChunkCacheBudget} evictions are routine - a far mesh gives bytes back
+     * 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);
+    /** Per-splat channels whose edits survive chunk eviction/reload (M7.6). */
+    u(this, "persistentChannels", /* @__PURE__ */ new Map());
+    /** Chunk-file index of the always-resident environment tile, if the scene ships one. */
+    u(this, "envFile");
+    /** Whether the environment tile should be visible; toggled live. */
+    u(this, "envEnabled");
+    /** Pool handle of the environment tile once it has loaded (kept for toggling). */
+    u(this, "envHandle");
+    /** Env splat count, measured when the tile decodes; 0 until then. */
+    u(this, "envSplatCount", 0);
+    /** Set when the env tile is larger than the whole pool - terminal, warned once. */
+    u(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");
+    /** Which hold, if any, was armed at construction. Survives release for recapture. */
+    u(this, "initialRevealHold", "off");
+    /** Frozen nearby-detail / in-view coverage runs for {@link initialRevealPhase} `'holding'`. */
+    u(this, "frozenCriticalRuns", null);
+    /** Timestamp of the final-camera capture that began the current hold. */
+    u(this, "initialRevealStartedAt");
+    u(this, "initialRevealStateValue", { status: "disabled" });
+    /** Fetch settings this mesh was loaded with, reused for collision meshes. */
+    u(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);
+    /** 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 = {
+      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({
+      // No weight supplied: claim an equal share rather than none, so a partly
+      // wired host degrades to round-robin instead of silently starving.
+      weight: () => {
+        var m;
+        return ((m = this.fetchWeight) == null ? void 0 : m.call(this)) ?? 1;
+      },
+      onSlotAvailable: () => {
+        this.pendingWork = !0;
+      },
+      shedFetches: (m) => this.abortFetches(m)
+    });
+    const h = j(n.foveationMode), f = h ? Math.max(
+      this.cpuCacheBytes,
+      Math.min(St, bt(e))
+    ) : this.cpuCacheBytes;
+    if (this.cacheBudgetHandle = (v = this.cacheBudget) == null ? void 0 : v.register({
+      // The governor weight `fetchWeight` already carries, so cache and network
+      // follow the same camera-projected measure. The `1` fallback matches
+      // `requestChunk`: a host that never wired weights gives every mesh an
+      // equal claim rather than none.
+      weight: () => {
+        var m;
+        return ((m = this.fetchWeight) == null ? void 0 : m.call(this)) ?? 1;
+      },
+      ceilingBytes: f,
+      onAllowanceChanged: (m) => this.applyCacheAllowance(m)
+    }), this.cacheLimitBytes = this.cacheBudget && this.cacheBudgetHandle ? this.cacheBudget.allowanceFor(this.cacheBudgetHandle) : f, h || (this.cpuCacheBytes = this.cacheLimitBytes), this.fetchCountsValue.cacheLimitBytes = this.cacheLimitBytes, j(n.foveationMode)) {
+      if (!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({
+        type: "init",
+        capacity: this.pagerSlots,
+        chunkSize: e.chunkSize ?? 65536,
+        cpuCacheBytes: this.cacheLimitBytes
+      });
+      const m = e.bootstrapChunk;
+      m && this.forwardChunkToWorker(m.file, m.data);
+    } else
+      this.frontierWorker = null;
+  }
+  /**
+   * Fetches a scene manifest and prepares a mesh sized to the budget.
+   * Accepts a Streamed SOG manifest (`lod-meta.json`) or an XGRIDS `.lcc2` or
+   * `.lcc` (manifest v3–v5) dataset - all stream through the same machinery. Both LCC
+   * generations are normalized to the established XGRIDS/Spark Three.js
+   * coordinate frame; streamed SOG orientation is unchanged.
+   *
+   * A `.lcc` dataset needs a server that answers HTTP range requests: its
+   * splats live in one large `data.bin` that is never fetched whole.
+   *
+   * @param manifestUrl - URL of the scene's `lod-meta.json`, `.lcc2` or `.lcc`
+   * file; relative URLs resolve against `options.baseUrl` (or the page).
+   * @throws Rejects with {@link SplatLoadError} on any resolve/fetch/parse
+   * 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";
+    return Y.fromSource(
+      nt(i, t.request),
+      a,
+      t
+    );
+  }
+  /**
+   * Prepares a mesh from a folder dropped into the page - the same streamed
+   * formats, read straight off the user's disk with no server and no upload.
+   *
+   * Every file becomes a `blob:` URL, which answers range requests exactly as
+   * an HTTP origin does, so a multi-hundred-megabyte `.lcc` `data.bin` streams
+   * chunk-by-chunk rather than being read whole.
+   *
+   * @param files - The folder's files, keyed by path relative to its root
+   * (as the demo drop-zone `readDirectory` walk produces).
+   * @throws Rejects with {@link SplatLoadError} - phase `'manifest'` when the
+   * folder holds no (or more than one) recognizable scene manifest - or a
+   * `DOMException` named `AbortError` when `options.signal` fires.
+   */
+  static async loadLocal(e, t = {}) {
+    let i;
+    try {
+      i = ot(e);
+    } catch (n) {
+      throw n instanceof q ? n : new q(n instanceof Error ? n.message : String(n), {
+        phase: "manifest",
+        url: "local-folder",
+        retryable: !1,
+        cause: n
+      });
+    }
+    try {
+      const n = await Y.fromSource(i.source, i.format, t);
+      return n.localSource = i.source, n;
+    } catch (n) {
+      throw i.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, {
+      format: t,
+      ...i.budgetCap === void 0 ? {} : { cap: i.budgetCap }
+    }), r = i.maxBudget === void 0 ? a : W(i.maxBudget, n);
+    if (r < a)
+      throw new RangeError(
+        `StreamedSplatMesh: maxBudget (${r}) 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();
+    let g;
+    if (t === "rad")
+      try {
+        const { buildRadScene: p } = await import("./formats/rad.js");
+        g = await p(e, l, i.request, c, f);
+      } catch (p) {
+        throw N(p) ? p : _(p, { phase: "manifest", url: e.manifestUrl });
+      }
+    else {
+      let p;
+      try {
+        p = await fetch(e.manifestUrl, ee(i.request, d));
+      } catch (S) {
+        throw N(S) ? S : _(S, { phase: "fetch", url: e.manifestUrl });
+      }
+      if (!p.ok)
+        throw _(
+          new Error(`Failed to load manifest ${e.manifestUrl}: HTTP ${p.status}`),
+          { phase: "manifest", url: e.manifestUrl, status: p.status }
+        );
+      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);
+        } else if (t === "lcc") {
+          const { buildLccScene: M } = await import("./formats/lcc.js");
+          g = await M(S, e, { ...l, shBands: c });
+        } else
+          g = tt(S, e, l, i.shBands ?? 0);
+      } catch (S) {
+        throw N(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);
+    g.source.budget = m;
+    const b = Math.min(v, g.maxResidentSplats), T = i.experimentalStagedSwaps !== !1 ? 1.5 : 1.4, I = Math.max(
+      1,
+      Math.ceil(b * T / F)
+    ), y = g.foveation ? ne(
+      i.foveationMode,
+      t === "rad" ? "page-table" : "frontier"
+    ) : i.foveationMode === void 0 ? void 0 : ne(i.foveationMode);
+    let A;
+    if (j(y)) {
+      A = (await import("./frontier-worker-CAnK_Cmu.js")).default, d == null || d.throwIfAborted();
+      const S = g.source;
+      S.needsParentSizes !== void 0 && (S.needsParentSizes = !1);
+    }
+    const R = new Y(
+      g,
+      m,
+      I * F,
+      {
+        ...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" } : {},
+        // The resolved ceiling, not the caller's raw option: it may have been
+        // lifted to a moderate capture's leaf count above.
+        maxBudget: v,
+        // This line overrides `...options` above, so a declined request has to
+        // survive it - that is how `.rad` came to ignore both the `smooth`
+        // profile and an explicit `shBands: 0`. Only *zero* is re-applied here,
+        // never a partial reduction: the builders already honour partial
+        // requests by generating that many bands, whereas forcing a smaller
+        // count past one would mismatch the decoded chunk and degrade to
+        // neutral SH (see `SplatMesh.writePackedSh`).
+        shBands: c === 0 ? 0 : g.shBands ?? 0,
+        // Spark ships Mip-Splatting antialiasing ON (blurAmount 0.3 *with* opacity
+        // 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),
+        // 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
+        // σ-cutoff/super-Gaussian, and the √8 (≈2.83σ) base cutoff Spark defaults to.
+        // An explicit `lodAlpha` (e.g. `?lodAlpha=0`) wins for A/B.
+        //
+        // The √8 cutoff is *desktop only* - see `recommendedRadMaxStdDev`, which
+        // returns undefined on mobile so the `SplatMesh` constructor applies the
+        // 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 } : {}
+        } : {},
+        // 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
+        // paged to the GPU, so the whole device budget buys on-screen detail); other
+        // foveated formats keep the GPU `frontier` cut. `foveationMode: 'band'` (or
+        // `'frontier'`) forces the legacy paths for A/B. Overrides any caller blob cull.
+        ...g.foveation ? {
+          foveationMode: y,
+          minSplatScreenRadius: g.foveation.minScreenRadiusPx,
+          maxSplatScreenRadius: g.foveation.maxScreenRadiusPx
+        } : {}
+      },
+      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;
+  }
+  /** Slots the currently reserved pages can hold. */
+  get slabSlots() {
+    let e = 0;
+    for (const t of this.slabPages) e += t.count;
+    return e;
+  }
+  /**
+   * Reserves or releases slab pages so the slab can hold `wanted` slots, and
+   * tells the worker's pager the new slot count.
+   *
+   * This is the mechanism that makes a shared pool worth having: storage follows
+   * the governed budget, so approaching a mesh grows its pages while the ones
+   * behind you hand theirs back, instead of every mesh holding its ceiling for
+   * the whole session. Growth stops at the construction ceiling and at whatever
+   * the pool can actually spare - a mesh that cannot grow simply stays coarse
+   * rather than throwing.
+   */
+  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);
+      if (n <= 0) break;
+      try {
+        this.slabPages.push(this.reserveInactiveRange(n));
+      } catch {
+        break;
+      }
+      i += 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);
+    }
+    i !== this.pagerSlots && (this.pagerSlots = i, this.postToWorker({ type: "resize", capacity: i }), this.pageTableDrawn > i && this.setSlabResident(i), this.pendingWork = !0, this.lastScheduleTime = -1 / 0);
+  }
+  /**
+   * Writes `data` at slot `slot`, splitting the write where it crosses a page
+   * boundary. The pager's runs are contiguous in *slot* space, which page
+   * storage no longer guarantees is contiguous in the pool.
+   */
+  writeSlabSlots(e, t, i) {
+    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;
+    }
+  }
+  /** 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)];
+      if (!a) return;
+      const r = n % this.slabPageSplats, l = Math.min(t - i, this.slabPageSplats - r);
+      this.degenerateRange(a, r, l), i += l;
+    }
+  }
+  /**
+   * Draws exactly the first `resident` slots: pages below the boundary are
+   * fully active, the page containing it is partially active, the rest are
+   * inactive. Freed tail slots simply leave the active list; they are also
+   * degenerated (see {@link degenerateSlabSlots}) so that even a slot drawn by
+   * mistake shows nothing.
+   */
+  setSlabResident(e) {
+    for (let t = 0; t < this.slabPages.length; t++) {
+      const i = Math.min(
+        this.slabPageSplats,
+        Math.max(0, e - t * this.slabPageSplats)
+      );
+      this.setRangeActivePrefix(this.slabPages[t], i);
+    }
+  }
+  /** Typed post to the frontier worker. */
+  postToWorker(e, t = []) {
+    var i;
+    (i = this.frontierWorker) == null || i.postMessage(e, t);
+  }
+  /**
+   * Applies a new decoded-chunk allowance from the scene's shared
+   * {@link ChunkCacheBudget}.
+   *
+   * Only the cap moves; nothing is dropped here. Both cache implementations
+   * evict lazily against it - the page-table worker inside its next
+   * `reschedule`, against a frontier that is still current, and the classic
+   * path in `evictChunks` on the next tick. Dropping chunks synchronously would
+   * pull them out from under resident splats.
+   *
+   * `pageTableCacheAtLimit` is recomputed here rather than waiting for the next
+   * plan, so a *raised* allowance re-arms the background sweep on this tick
+   * instead of one idle interval later.
+   */
+  applyCacheAllowance(e) {
+    this.disposed || e !== this.cacheLimitBytes && (this.cacheLimitBytes = e, this.frontierWorker ? this.postToWorker({ type: "cacheBudget", cpuCacheBytes: e }) : this.cpuCacheBytes = e, this.fetchCountsValue.cacheLimitBytes = e, this.pageTableCacheAtLimit = this.fetchCountsValue.cacheBytes >= e, this.pendingWork = !0);
+  }
+  /**
+   * Whether this scene ships collision meshes - true for an XGRIDS `.lcc` /
+   * `.lcc2` dataset that carries them, false for a Streamed SOG scene, which
+   * has none.
+   */
+  get hasCollisionMeshes() {
+    var e;
+    return (((e = this.scene.collision) == null ? void 0 : e.meshes.length) ?? 0) > 0;
+  }
+  /**
+   * Fetches and parses this scene's collision geometry: the triangle meshes an
+   * XGRIDS `.lcc` (`collision.lci`) or `.lcc2` (`data/mesh/*.ply`) capture
+   * ships beside its splats, for hosts that want collision, ground probes or
+   * other spatial queries.
+   *
+   * The geometry is source-local, like {@link StreamedScene.bounds} - apply
+   * this mesh's `matrixWorld` to put it in the frame the splats render in.
+   * VLAM! builds no acceleration structure over it and never consults it.
+   *
+   * Tiles are fetched once and cached; concurrent callers share one load, and
+   * a failed load can be retried by calling again. Resolves `[]` for a scene
+   * without collision.
+   *
+   * @throws a `DOMException` named `AbortError` if cancelled, or if
+   * {@link dispose} is called while the load is in flight.
+   */
+  async loadCollisionMeshes(e = {}) {
+    var a;
+    (a = e.signal) == null || a.throwIfAborted();
+    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, {
+          ...this.requestOptions ? { request: this.requestOptions } : {},
+          signal: r.signal
+        })
+      ).catch((l) => {
+        throw this.collisionTiles = void 0, l;
+      });
+    }
+    const { signal: i } = e;
+    if (!i) 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 });
+        })
+      ]);
+    } finally {
+      n && i.removeEventListener("abort", n);
+    }
+  }
+  /**
+   * Whether this scene ships an always-resident environment/background tile -
+   * true for an XGRIDS `.lcc2` capture that carries one (its `env.sog` sky),
+   * false for Streamed SOG, `.lcc`, `.rad`, or an `.lcc2` without one.
+   */
+  get hasEnvironment() {
+    return this.envFile !== void 0;
+  }
+  /** Whether the environment tile is currently set to render. */
+  get environmentEnabled() {
+    return this.envEnabled;
+  }
+  /**
+   * Splats in the environment tile, measured when it decoded - the manifest
+   * does not carry the count. 0 until the tile has loaded (or if the scene
+   * ships none). These sit outside the LOD budget, drawing from the pool's
+   * capacity headroom.
+   */
+  get environmentSplatCount() {
+    return this.envSplatCount;
+  }
+  /**
+   * Shows or hides the scene's environment/background tile. The switch is
+   * instant and never refetches: once loaded, the tile stays in the pool and
+   * only its active flag flips. Enabling before the tile has loaded triggers
+   * its (one-time) load on the next update. No-op on a scene without one.
+   */
+  setEnvironmentEnabled(e) {
+    this.envFile === void 0 || e === this.envEnabled || (this.envEnabled = e, this.envHandle !== void 0 ? this.setRangeActive(this.envHandle, e) : e && (this.pendingWork = !0, this.lastScheduleTime = -1 / 0));
+  }
+  /** The active-splat budget this mesh keeps within. */
+  get budget() {
+    return this.budgetValue;
+  }
+  /**
+   * The ceiling {@link setBudget} clamps to - {@link StreamedSplatMeshOptions.maxBudget}
+   * when one was given, otherwise the construction budget.
+   *
+   * The pool was allocated for this number and cannot grow, so it is a hard
+   * limit on what any governor can hand this mesh. Read it to check that a
+   * shared-budget setup can actually deliver the share it is computing.
+   */
+  get maxBudget() {
+    return this.maximumBudget;
+  }
+  /** Alias used by hosts that manage static and streamed auto-LOD uniformly. */
+  get budgetCeiling() {
+    return this.maximumBudget;
+  }
+  /**
+   * The capture's real content size, when the format declares it (`.rad` reports
+   * its leaf count) - the splat count needed to hold this mesh at full
+   * resolution, independent of the budget it was constructed with.
+   *
+   * A host splitting one budget across several streamed meshes should clamp each
+   * share to this: a mesh cannot spend more than it contains, so budget handed
+   * past it buys nothing and is better given to a mesh that can use it. Note it
+   * is *not* `maxBudget`: a foveated `.rad` reports `maxResidentSplats` as the
+   * requested budget, because its pool holds a camera-directed resident set
+   * rather than the whole tree.
+   *
+   * `undefined` when the format does not declare a content size.
+   */
+  get contentSplatCount() {
+    return this.scene.contentSplatCount;
+  }
+  /**
+   * Which `.rad` streaming strategy this mesh selected at load, or `null` when
+   * the scene is not a Spark `.rad` capture.
+   */
+  get radStrategy() {
+    var e, t;
+    return ((t = (e = this.scene.chunkOptions) == null ? void 0 : e[0]) == null ? void 0 : t.format) !== "rad-chunk" ? null : this.frontierWorker ? "page-table" : "prefix";
+  }
+  /**
+   * The drawn-splat target currently driving the `.rad` page-table frontier -
+   * the governed budget, capped by
+   * {@link SplatMeshOptions.foveationDrawBudget}. `0` on a mesh that is not in
+   * `foveationMode: 'page-table'`, which has no frontier to target.
+   *
+   * This is the number that decides how deep the traversal descends, so it is
+   * what to watch when checking that a near mesh really did receive more
+   * detail: {@link budget} is the pool's allowance, this is what is spent.
+   */
+  get drawBudget() {
+    return this.frontierWorker ? this.pageTableDrawBudget : 0;
+  }
+  /**
+   * Page-table frontier coherence for hosts that gate preload/transitions.
+   * `undefined` fields stay 0 when this mesh is not in page-table mode.
+   */
+  get frontierState() {
+    return {
+      frontierConverged: this.frontierWorker ? this.frontierConverged : !0,
+      pendingFrontierSplats: this.pendingFrontierSplats,
+      staleResidentSplats: this.staleResidentSplats,
+      lastPlanAppends: this.lastPlanAppends,
+      lastPlanMoves: this.lastPlanMoves,
+      planGeneration: this.lastPlanGeneration,
+      planBudget: this.lastPlanBudget,
+      lastPlanCamera: this.lastPlanCamera,
+      firstFrontierCamera: this.firstFrontierCamera
+    };
+  }
+  /**
+   * Spark's per-mesh `lodScale` (see {@link StreamedSplatMeshOptions.lodScale}).
+   * Mutable: raise it to sharpen a focused mesh, lower it to coarsen a
+   * background one. Page-table `.rad` only.
+   *
+   * @throws {RangeError} if set to a value that is not positive and finite.
+   */
+  get lodScale() {
+    return this.lodScaleValue;
+  }
+  set lodScale(e) {
+    const t = ce(e);
+    t !== this.lodScaleValue && (this.lodScaleValue = t, this.pendingWork = !0, this.lastScheduleTime = -1 / 0);
+  }
+  /** In `page-table` mode the slab is fully active but mostly degenerate, so the
+   * base `activeSplatCount` (slab size) is not the on-screen count - report the
+   * frontier's drawn size instead. */
+  get activeSplatCount() {
+    return this.frontierWorker ? this.pageTableDrawn : super.activeSplatCount;
+  }
+  /**
+   * Updates the LOD budget used for future scheduling within allocated capacity.
+   *
+   * @returns the budget actually in effect, which is `budget` clamped to
+   * {@link maxBudget}. A `BudgetGovernor` reads this return value to detect a
+   * capped member and hand the remainder to the others, so the clamp is
+   * reported rather than hidden.
+   */
+  setBudget(e) {
+    const t = Math.min(W(e), this.maximumBudget);
+    return t === this.budgetValue ? this.budgetValue : (this.budgetValue = t, this.scene.source.budget = t, this.frontierWorker && (this.pageTableDrawBudget = Math.min(t, this.pageTableDrawTarget), this.syncSlabPages(this.pageTableDrawBudget), this.pageTableDrawTargetExplicit && this.pageTableDrawTarget < t && !this.warnedDrawTargetCap && (this.warnedDrawTargetCap = !0, E(
+      `StreamedSplatMesh: budget raised to ${t} but foveationDrawBudget caps the drawn frontier at ${this.pageTableDrawTarget}; the extra budget cannot buy detail. Raise or drop foveationDrawBudget to let the shared budget through.`
+    ))), this.pendingWork = !0, this.lastScheduleTime = -1 / 0, t);
+  }
+  /**
+   * What the LOD scheduler last decided, or `undefined` on sources that do not
+   * schedule by leaf (the `.rad` page table, prefix readers).
+   *
+   * Distinct from {@link activeSplatCount}, and the distinction is the whole
+   * point: `desired` is what the scheduler asked for, `activeSplatCount` is
+   * what the pool ended up drawing. Equal means the cut is applied; `desired`
+   * far below the budget means the *scheduler* declined to spend it, which is a
+   * different bug from the mesh failing to apply what it was given.
+   */
+  get lodStats() {
+    return this.scene.source.stats;
+  }
+  /** Number of chunk files currently decoded and held. In page-table mode the
+   * worker owns the cache - the main-thread map is always empty there, so report
+   * what has been forwarded to it instead of a permanent zero. */
+  get residentChunkCount() {
+    return this.frontierWorker ? this.pageTableCachedFiles.size : this.cache.size;
+  }
+  /** Chunk fetches currently in flight. */
+  get pendingChunkCount() {
+    return this.fetching.size;
+  }
+  /**
+   * Main-thread cost of applying paging plans in `foveationMode: 'page-table'`.
+   *
+   * A plan is applied whole, off the render loop's own timing, so its cost does
+   * not appear in {@link getUpdateTimings} - but it lands on the same thread and
+   * a churning frontier can make it the largest stall in a frame. `worst*`
+   * accumulate over the mesh's lifetime; the rest describe the most recent plan.
+   */
+  get planTimings() {
+    return this.planTimingsValue;
+  }
+  /**
+   * Lifetime chunk-fetch totals by kind, plus page-table cache state.
+   *
+   * Diagnostic for the question "why is this still streaming after the view
+   * settled?", which the three fetch sources answer differently and which no
+   * other reading distinguishes:
+   *
+   * - **`sweep` climbing** - speculative file-order pre-warming of the whole
+   *   capture. Declined by the `smooth` profile; see `sweepAllowed`.
+   * - **`priority` / `base` climbing while `evicted` climbs too** - the
+   *   frontier's touched set does not fit the worker cache, so chunks are
+   *   evicted and immediately refetched. Streaming never ends because it cannot.
+   * - **`priority` / `base` climbing with `evicted` flat** - ordinary refinement
+   *   still converging on the cut; it should stop on its own.
+   *
+   * `uncovered` and `retiredEarly` answer a different question - "why are there
+   * holes?" - and between them cover both ways this class can render nothing
+   * where it should render something:
+   *
+   * - **`uncovered` climbing after the scene settles** - `substituteCoverage`
+   *   wanted a leaf's coarsest level as a stand-in and its chunk was not
+   *   cached. Expected briefly during initial load; afterwards it should not
+   *   move, because the coarsest files are pinned against eviction.
+   * - **`retiredEarly` climbing** - coverage was retired before its replacement
+   *   landed, under pool pressure or past the retirement hold bound. This is
+   *   the swap path rather than the substitute path, and it is the one that
+   *   scales with the budget.
+   *
+   * Both are counted in whole leaves/groups, monotonically: they answer "did
+   * this happen, and is it still happening", not "how much is missing now".
+   */
+  get fetchCounts() {
+    return this.fetchCountsValue;
+  }
+  /** Chunk files given up on after repeated fetch/decode failures. */
+  get failedChunkCount() {
+    return this.failedFiles.size;
+  }
+  /**
+   * Forgets all permanent chunk failures so their regions are fetched again.
+   * Failures are otherwise terminal for the mesh's lifetime - call this when
+   * the cause was transient (e.g. connectivity restored, `online` event).
+   */
+  retryFailedChunks() {
+    this.failedFiles.size !== 0 && (this.failedFiles.clear(), this.retrying.clear(), this.pendingWork = !0);
+  }
+  /**
+   * Whether the scene is still resolving toward its target detail - chunks
+   * are fetching, or a retry/append is pending. Goes false once the view
+   * has settled (useful to drive a loading indicator).
+   */
+  get isStreaming() {
+    return this.pendingWork || this.fetching.size > 0 || this.retrying.size > 0;
+  }
+  /** The LOD distance model (mutable; e.g. raise to force the finest level). */
+  get lodBaseDistance() {
+    return this.scene.source.lodBaseDistance;
+  }
+  set lodBaseDistance(e) {
+    this.scene.source.lodBaseDistance = e, this.pendingWork = !0;
+  }
+  update(e, t, i = {}) {
+    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 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);
+    }
+  }
+  /** Root bounds of the whole scene, valid before any chunk has loaded. */
+  computeSplatBounds() {
+    return this.scene.bounds.clone();
+  }
+  /**
+   * Enables or disables writing each resident run's **resolved** LOD level into
+   * the `lodLevel` float channel (for a false-color debug modifier: 0 = finest).
+   * Values come from applied desired runs after budget resolution - not from
+   * distance ambition alone. Call before assigning a modifier that reads the channel.
+   */
+  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);
+      return;
+    }
+    this.lodLevelDebug = !1;
+  }
+  /** Whether {@link setLodLevelDebug} is currently writing levels. */
+  get isLodLevelDebug() {
+    return this.lodLevelDebug;
+  }
+  /**
+   * Startup-hold progress for {@link StreamedSplatMeshOptions.initialReveal}.
+   * Hosts using `'hold-near-l0'` or `'hold-coverage'` should keep the mesh
+   * invisible while `status === 'pending'`, then reveal on `'ready'` or
+   * `'degraded'`.
+   */
+  get initialRevealState() {
+    return this.initialRevealStateValue;
+  }
+  /**
+   * Captures a fresh startup-hold set on the next {@link update}. Hosts that
+   * apply their final initial camera pose after the mesh first receives frames
+   * should call this before lifting their loading cover. It is a no-op when
+   * the hold was never armed (progressive startup, or a format without the
+   * matching LodSource hook).
+   */
+  recaptureInitialReveal() {
+    this.initialRevealHold !== "off" && (this.frozenCriticalRuns = null, this.initialRevealStartedAt = void 0, this.initialRevealPhase = "capture", this.initialRevealStateValue = {
+      status: "pending",
+      stagedSplats: 0,
+      totalSplats: 0,
+      readyGroups: 0,
+      totalGroups: 0
+    }, this.pendingWork = !0);
+  }
+  writeLodLevelChannel(e, t) {
+    !this.lodLevelDebug || e.count === 0 || ((!this.lodLevelScratch || this.lodLevelScratch.length < e.count) && (this.lodLevelScratch = new Float32Array(e.count)), this.lodLevelScratch.fill(t, 0, e.count), this.writeChannel(e, "lodLevel", this.lodLevelScratch.subarray(0, e.count)));
+  }
+  /**
+   * Declares a per-splat channel whose values **persist across LOD churn**:
+   * edits are stored sparsely keyed by `(chunk file, local index)` - a stable
+   * splat identity in the streaming design - and re-applied whenever a chunk
+   * is (re)appended. Paint a region with {@link paintPersistent}, orbit away
+   * until it is evicted, come back, and the values return. See M7.6.
+   *
+   * Wraps {@link SplatMesh.defineChannel}; read it from a modifier with
+   * `ctx.channel(name)` as usual.
+   */
+  definePersistentChannel(e, t = {}) {
+    this.defineChannel(e, t), this.persistentChannels.set(e, {
+      type: t.type ?? "float",
+      fill: t.fill ?? 0,
+      maxEdits: Math.max(1, Math.floor(t.maxEdits ?? 1e6)),
+      edits: /* @__PURE__ */ new Map(),
+      total: 0,
+      warned: !1
+    });
+  }
+  /**
+   * Sets a persistent channel to `value` for every currently-resident splat
+   * within `radius` (world units) of `worldPoint`, and records the edit so it
+   * survives eviction/reload. Splats whose chunk is not currently decoded on
+   * the CPU cannot be located and are skipped (they are usually far from the
+   * camera); their painted neighbours in resident chunks are unaffected.
+   *
+   * The radius assumes this mesh's world transform is rigid (rotation +
+   * translation, as the built-in format transforms are); a scaled mesh would
+   * distort the brush. Edit a persistent channel only through this method -
+   * direct {@link SplatMesh.writeChannel} writes are not recorded and are
+   * overwritten by the next re-apply.
+   *
+   * @returns the number of splats edited this call.
+   * @throws {Error} if the channel was not declared with
+   *   {@link definePersistentChannel}.
+   */
+  paintPersistent(e, t, i, n) {
+    const a = this.persistentChannels.get(e);
+    if (!a)
+      throw new Error(
+        `StreamedSplatMesh.paintPersistent: channel "${e}" is not a persistent channel. Call definePersistentChannel("${e}") first.`
+      );
+    V.copy(t), this.worldToLocal(V);
+    const r = i * i;
+    let l = 0;
+    const c = /* @__PURE__ */ new Set();
+    for (const { run: h } of this.resident.values()) {
+      const f = this.cache.get(h.file);
+      if (!f) continue;
+      const d = f.data.positions, g = a.edits.get(h.file) ?? /* @__PURE__ */ new Map();
+      let v = !1;
+      for (let m = 0; m < h.count; m++) {
+        const b = h.offset + m, T = d[b * 3 + 0] - V.x, I = d[b * 3 + 1] - V.y, y = d[b * 3 + 2] - V.z;
+        if (!(T * T + I * I + y * y > r) && !g.has(b)) {
+          if (a.total >= a.maxEdits) {
+            a.warned || (a.warned = !0, E(
+              `StreamedSplatMesh.paintPersistent: channel "${e}" hit its maxEdits cap (${a.maxEdits}); further new edits are dropped.`
+            ));
+            continue;
+          }
+          a.total++, g.set(b, n), v = !0, l++;
+        }
+      }
+      v && (a.edits.set(h.file, g), c.add(h.file));
+    }
+    if (c.size > 0)
+      for (const { run: h, handle: f } of this.resident.values())
+        c.has(h.file) && this.applyPersistentRun(e, a, h, f);
+    return l;
+  }
+  /**
+   * Clears every stored edit for a persistent channel and zeroes the value on
+   * all currently-resident splats. Chunks that are not resident are covered by
+   * the emptied store - they reload at the channel's fill value.
+   *
+   * @throws {Error} if the channel is not a persistent channel.
+   */
+  clearPersistentChannel(e) {
+    const t = this.persistentChannels.get(e);
+    if (!t)
+      throw new Error(
+        `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);
+      this.writeChannel(n, e, a);
+    }
+  }
+  dispose() {
+    var e, t, i, n, a;
+    if (!this.disposed) {
+      this.loader.dispose(), this.frontierWorker && (this.frontierWorker.onmessage = null, this.frontierWorker.terminate()), this.pageTableDisposed = !0, (e = this.collisionAbort) == null || e.abort(), (t = this.collisionTiles) == null || t.catch(() => {
+      }), this.collisionTiles = void 0;
+      for (const { controller: 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);
+      }
+      (a = this.localSource) == null || a.dispose(), this.localSource = void 0, this.cache.clear(), this.cacheBytesTotal = 0, this.retrying.clear(), this.failedFiles.clear(), this.neededFiles.clear(), this.persistentChannels.clear(), this.resident.clear(), this.staged.clear(), this.pageTableCachedFiles.clear(), this.envHandle = void 0, this.envSplatCount = 0, super.dispose();
+    }
+  }
+  shouldReschedule(e, t) {
+    if (this.pendingWork || t - this.lastScheduleTime > ft) return !0;
+    e.getWorldPosition(pe);
+    const i = this.scene.bounds.getBoundingSphere(wt).radius || 1;
+    return pe.distanceTo(this.lastCameraPos) > i * 25e-4 ? !0 : (e.getWorldQuaternion(me), me.angleTo(this.lastCameraQuat) > 87e-4);
+  }
+  reschedule(e, t) {
+    var L;
+    const i = performance.now();
+    let n = null;
+    if (this.onPerformanceEvent !== void 0) {
+      n = { resident: /* @__PURE__ */ new Map(), staged: /* @__PURE__ */ new Map() };
+      for (const [p, S] of this.resident) n.resident.set(p, S.run.count);
+      for (const [p, S] of this.staged) n.staged.set(p, S.uploadedCount);
+    }
+    const a = this.compactionCount;
+    if (this.pendingWork = !1, this.lastScheduleTime = t, e.getWorldPosition(this.lastCameraPos), e.getWorldQuaternion(this.lastCameraQuat), x.copy(this.lastCameraPos), this.worldToLocal(x), ve.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse).multiply(this.matrixWorld), O.setFromProjectionMatrix(ve), this.frontierWorker) {
+      e.getWorldDirection(B).add(this.lastCameraPos), this.worldToLocal(B), B.sub(x).normalize();
+      const p = e.projectionMatrix.elements[5] * this.pageTableViewportY / 2;
+      if (p > 0 && (this.pageTableLimit = this.pageTableTargetPx / p), this.reschedulePageTable(x, B, O, t), this.onPerformanceEvent === void 0) return null;
+      const S = performance.now();
+      return {
+        timestamp: S,
+        cpuMs: S - i,
+        activeListMs: 0,
+        uploadMs: 0,
+        sortSubmitMs: 0,
+        stagingTextureAllocations: 0,
+        activeListUpdateRanges: 0,
+        appendedCount: 0,
+        removedCount: 0,
+        stagedCount: 0,
+        uploadCount: 0,
+        activeCount: this.pageTableDrawn,
+        forcedSort: !1,
+        compacted: !1
+      };
+    }
+    e.getWorldDirection(B).add(this.lastCameraPos), this.worldToLocal(B), B.sub(x).normalize();
+    const r = this.scene.source.computeDesiredRuns(
+      x,
+      O,
+      t,
+      B
+    ), l = this.captureOrContinueInitialReveal(
+      r,
+      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);
+    for (const [p, S] of this.staged)
+      f.has(p) || c && ((L = this.frozenCriticalRuns) != null && L.some((M) => C(M) === p)) || (this.removeRange(S.handle), this.staged.delete(p));
+    for (const [p, { controller: S }] of this.fetching)
+      !d.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);
+    this.neededFiles.clear();
+    for (const p of h) {
+      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);
+    }
+    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 ? (
+      // 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.
+      _e(g)
+    ) : Oe(g, v), b = !c && ze(m);
+    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;
+    for (const p of m) {
+      if (!b && p.removes.length > 0 && y) {
+        if (this.neverRetireCoverageEarly || !A && this.retireHeldTicks < ut) {
+          this.pendingWork = !0, R = !0;
+          continue;
+        }
+        this.fetchCountsValue.retiredEarly++;
+      }
+      if (p.adds.length === 0) {
+        this.applyGroup(p, t);
+        continue;
+      }
+      const S = p.adds.filter((P) => !this.cache.has(P.file)), M = 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,
+            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.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) => {
+          var se;
+          return ((se = this.staged.get(C(k))) == null ? void 0 : se.uploadedCount) === k.count;
+        })) {
+          this.pendingWork = !0, y = !0;
+          continue;
+        }
+        if (P > 0 && !c) {
+          this.deferNextSortRequest(), this.pendingWork = !0, y = !0;
+          continue;
+        }
+        this.commitStagedGroup(p);
+        continue;
+      }
+      if (!c && I > 0 && I + p.addCount > this.appendCap) {
+        this.pendingWork = !0, y = !0;
+        continue;
+      }
+      if (c) {
+        this.pendingWork = !0, y = !0;
+        continue;
+      }
+      if (!this.applyGroup(p, t)) {
+        this.pendingWork = !0, A = !0;
+        continue;
+      }
+      I += 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(
+      n.resident,
+      n.staged,
+      a,
+      i
+    );
+  }
+  rowAlignedSplats(e) {
+    return Math.ceil(e / F) * F;
+  }
+  /**
+   * Startup hold seeds: the coverage group containing (or nearest to) the
+   * camera within {@link LodSource.lodBaseDistance}. HiRes tiles often fail the
+   * frustum test when most of the cell sits behind the camera - do **not**
+   * require `inView`, or the hold seeds a screen-facing neighbour instead.
+   * Coarser home levels come from {@link LodSource.runsAtLevelFor}.
+   */
+  selectHomeSeedRuns(e) {
+    var a;
+    const t = this.scene.source.lodBaseDistance, i = e.filter(
+      (r) => r.coverageGroup !== void 0 && (r.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);
+  }
+  coarsenHomeRuns(e, t) {
+    var a;
+    const i = [], n = this.scene.source;
+    for (const r of e) {
+      if (r.level === t) {
+        i.push(r);
+        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({
+            ...c,
+            distance: r.distance,
+            inView: r.inView,
+            ...r.coverageGroup === void 0 ? {} : { coverageGroup: r.coverageGroup },
+            ...r.screenImportance === void 0 ? {} : { screenImportance: r.screenImportance }
+          });
+    }
+    return i;
+  }
+  criticalRunsFitCapacity(e) {
+    let t = 0;
+    for (const i of e) t += this.rowAlignedSplats(i.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);
+    }
+    let i = 0, n = 0, a = 0;
+    for (const l of t.values()) {
+      let c = !0;
+      for (const h of l) {
+        n += h.count;
+        const f = C(h);
+        if (this.resident.has(f)) {
+          i += h.count;
+          continue;
+        }
+        const d = this.staged.get(f);
+        i += (d == null ? void 0 : d.uploadedCount) ?? 0, (!d || d.uploadedCount !== h.count) && (c = !1);
+      }
+      c && a++;
+    }
+    const r = this.initialRevealStateValue;
+    if (r.status === "degraded") {
+      this.initialRevealStateValue = {
+        status: "degraded",
+        reason: r.reason,
+        stagedSplats: i,
+        totalSplats: n,
+        readyGroups: a,
+        totalGroups: t.size
+      };
+      return;
+    }
+    this.initialRevealStateValue = {
+      status: "pending",
+      stagedSplats: i,
+      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;
+    e === "ready" ? this.initialRevealStateValue = { status: "ready" } : this.initialRevealStateValue = {
+      status: "degraded",
+      reason: t ?? "fetch-failed",
+      stagedSplats: a,
+      totalSplats: r,
+      readyGroups: l,
+      totalGroups: c
+    }, this.frozenCriticalRuns = null, this.initialRevealPhase = "released", this.pendingWork = !0;
+  }
+  /**
+   * `.lcc2` coverage hold: freeze coarsest covering runs for in-view cells.
+   * Missing `coverageRunsFor` (or an empty result after fallback) releases
+   * immediately so the mesh does not stay hidden with nothing to fetch.
+   */
+  captureCoverageHold(e, t, i) {
+    var a, r;
+    const n = ((r = (a = this.scene.source).coverageRunsFor) == null ? void 0 : r.call(a, e, t)) ?? [];
+    if (n.length === 0) {
+      if (this.environmentPendingForReveal()) {
+        this.frozenCriticalRuns = [], this.initialRevealStartedAt = i, 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;
+    }
+    this.frozenCriticalRuns = n, this.initialRevealStartedAt = i, this.initialRevealPhase = "holding", this.publishInitialRevealProgress(n);
+  }
+  captureOrContinueInitialReveal(e, t, i, n) {
+    if (this.initialRevealPhase === "off" || this.initialRevealPhase === "released") return null;
+    if (this.initialRevealPhase === "capture")
+      if (this.initialRevealHold === "hold-coverage")
+        this.captureCoverageHold(i, n, t);
+      else {
+        const a = this.selectHomeSeedRuns(e);
+        let r = [];
+        if (a.length === 0) {
+          const l = this.scene.source.lodBaseDistance * this.scene.source.lodMultiplier * this.scene.source.lodMultiplier, c = e.filter(
+            (f) => f.level <= 2 && f.coverageGroup !== void 0 && (f.distance ?? Number.POSITIVE_INFINITY) <= l
+          ), h = [...c].sort(
+            (f, d) => (f.distance ?? Number.POSITIVE_INFINITY) - (d.distance ?? Number.POSITIVE_INFINITY) || (f.inView === !0 ? 0 : 1) - (d.inView === !0 ? 0 : 1) || (f.screenImportance ?? Number.POSITIVE_INFINITY) - (d.screenImportance ?? Number.POSITIVE_INFINITY) || f.leafStart - d.leafStart
+          )[0];
+          if (!h)
+            return this.initialRevealStateValue = { status: "ready" }, this.initialRevealPhase = "released", null;
+          if (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;
+          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;
+                break;
+              }
+              r = c;
+            }
+          }
+          if (r.length === 0)
+            return this.initialRevealStateValue = { status: "ready" }, this.initialRevealPhase = "released", null;
+          if (!this.criticalRunsFitCapacity(r))
+            return this.frozenCriticalRuns = r, this.releaseInitialReveal("degraded", "capacity"), null;
+          this.frozenCriticalRuns = r, this.initialRevealStartedAt = t, this.initialRevealPhase = "holding", this.publishInitialRevealProgress(r);
+        }
+      }
+    if (this.initialRevealPhase !== "holding" || !this.frozenCriticalRuns) return null;
+    if (this.initialRevealStartedAt !== void 0 && t - this.initialRevealStartedAt >= ct)
+      return this.releaseInitialReveal("degraded", "timeout"), null;
+    for (const a of this.frozenCriticalRuns)
+      if (this.failedFiles.has(a.file) && !this.resident.has(C(a))) {
+        const r = this.staged.get(C(a));
+        if (!r || r.uploadedCount !== a.count)
+          return this.releaseInitialReveal("degraded", "fetch-failed"), null;
+      }
+    return this.publishInitialRevealProgress(this.frozenCriticalRuns), this.frozenCriticalRuns;
+  }
+  /** After staging/commits, release the hold when every frozen run is resident. */
+  finishInitialRevealIfComplete() {
+    this.initialRevealPhase !== "holding" || !this.frozenCriticalRuns || (this.publishInitialRevealProgress(this.frozenCriticalRuns), !this.environmentPendingForReveal() && this.frozenCriticalRuns.every((e) => this.resident.has(C(e))) && this.releaseInitialReveal("ready"));
+  }
+  /**
+   * Startup hold still needs the environment tile when the scene ships one
+   * and it starts enabled. Failed / unfit / disabled tiles do not block reveal.
+   */
+  environmentPendingForReveal() {
+    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);
+    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;
+    const f = performance.now();
+    return {
+      timestamp: f,
+      cpuMs: f - n,
+      activeListMs: 0,
+      uploadMs: 0,
+      sortSubmitMs: 0,
+      stagingTextureAllocations: 0,
+      activeListUpdateRanges: 0,
+      appendedCount: a,
+      removedCount: l,
+      stagedCount: c,
+      uploadCount: a + c,
+      activeCount: r,
+      forcedSort: r === 0 || a + l >= r * ht,
+      compacted: h
+    };
+  }
+  /** Returns whether all new rows can coexist with the currently visible region. */
+  canStageGroup(e) {
+    return e.adds.filter((i) => !this.staged.has(C(i))).reduce((i, n) => i + this.rowAlignedSplats(n.count), 0) <= this.freeSplatCapacity;
+  }
+  /**
+   * Uploads a bounded part of a replacement without rendering it.
+   * Skips runs whose chunks are not yet cached so siblings can stage out of order.
+   */
+  stageGroup(e, t, i) {
+    if (i <= 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);
+      if (!c) {
+        let f;
+        try {
+          f = this.reserveInactiveRange(a.count);
+        } catch {
+          this.compactionCount++, this.compact();
+          try {
+            f = this.reserveInactiveRange(a.count);
+          } catch {
+            this.pendingWork = !0;
+            break;
+          }
+        }
+        c = { run: a, handle: f, uploadedCount: 0 }, this.staged.set(r, c);
+      }
+      if (c.uploadedCount === a.count) continue;
+      const h = Math.min(a.count - c.uploadedCount, i - n);
+      if (h <= 0) break;
+      if (this.writeInactiveRange(
+        c.handle,
+        K(l.data, a.offset + c.uploadedCount, h),
+        c.uploadedCount
+      ), c.uploadedCount += h, l.lastUsed = t, n += h, c.uploadedCount === a.count) {
+        this.writeLodLevelChannel(c.handle, a.level);
+        for (const [f, d] of this.persistentChannels)
+          this.applyPersistentRun(f, d, a, c.handle);
+      }
+      if (n >= i) break;
+    }
+    return n;
+  }
+  /** Switches a fully staged region from old to new visibility in one tick. */
+  commitStagedGroup(e) {
+    for (const t of e.adds) {
+      const i = this.staged.get(C(t));
+      if (!i || i.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 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);
+    }
+  }
+  /**
+   * Applies one swap group atomically within this tick: removals first
+   * (freeing pool rows for the replacements), then all adds. Returns false
+   * without touching anything when the group cannot fit even after its own
+   * 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);
+    if (n > this.freeSplatCapacity + a) return !1;
+    for (const [r, l] of e.removes)
+      this.resident.has(r) && (this.removeRange(l.handle), this.resident.delete(r));
+    for (const r of e.adds)
+      this.appendRun(r, t);
+    return !0;
+  }
+  /** Appends one run from the cache, compacting the pool on fragmentation. */
+  appendRun(e, t) {
+    const i = this.cache.get(e.file);
+    if (!i) return;
+    const n = K(i.data, e.offset, e.count);
+    let a;
+    try {
+      a = this.appendRange(n);
+    } catch {
+      this.compactionCount++, this.compact();
+      try {
+        a = this.appendRange(n);
+      } catch {
+        this.pendingWork = !0;
+        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);
+  }
+  /**
+   * 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);
+    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);
+    }
+    l && this.writeChannel(n, e, r);
+  }
+  /**
+   * Covers a deferred group's leaves that no resident run covers with each
+   * leaf's coarsest (pinned, hence cached) level, so a region waiting on a
+   * fetch shows coarse detail instead of nothing. The substitutes are
+   * intentionally not "desired": the next reschedule swaps them for the
+   * real level once its chunk has arrived.
+   *
+   * Near-camera refinements (`distance <= lodBaseDistance`) skip the coarse
+   * 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) {
+    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 l = r.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;
+      for (const m of this.scene.source.coarsestRunsFor(g, v))
+        if (!this.resident.has(C(m))) {
+          if (n) {
+            this.fetchCountsValue.uncovered += Math.min(m.leafEnd, v) - Math.max(m.leafStart, g);
+            continue;
+          }
+          if (!this.cache.has(m.file)) {
+            oe(
+              i,
+              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));
+          this.appendRun(m, t);
+        }
+      c = d;
+    }
+  }
+  /** Issues pending classic-path chunk wants in group-priority order. */
+  flushClassicFetches(e, t, i = !1) {
+    if (e.size === 0) return;
+    $e(e, t, i);
+    const n = [...e.entries()].sort(
+      (a, r) => X(a[1], r[1], a[0], r[0])
+    );
+    this.preemptClassicFetches(n);
+    for (const [a, r] of n) this.requestChunk(a, r.kind, r);
+  }
+  /**
+   * A camera turn must not wait for all eight old visible requests to finish.
+   * Only classic requests carry a precise rank; page-table work retains its
+   * own scheduler and is never cancelled here.
+   */
+  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;
+    }
+  }
+  /**
+   * Loads the always-resident environment tile once, on the first update after
+   * it is wanted. The tile has no LOD ladder and no manifest count, so it is
+   * appended whole (measuring its splat count at decode) and thereafter toggled
+   * by flipping its pool range active - never scheduled, refetched, or evicted.
+   * When `pending` is supplied, a miss is ranked as an `'environment'` want so
+   * 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)
+      return;
+    const n = this.cache.get(i);
+    if (!n) {
+      this.failedFiles.has(i) || (t ? this.enqueueEnvironmentFetch(t, i) : this.requestChunk(i, "priority"), this.pendingWork = !0);
+      return;
+    }
+    const a = Math.ceil(n.data.count / F) * F;
+    if (a > this.capacity) {
+      this.envUnfit = !0, E(
+        `the environment tile (${n.data.count} splats) exceeds the pool capacity (${this.capacity}); it will not be shown. Raise the splat budget to fit it.`
+      );
+      return;
+    }
+    if (a > this.freeSplatCapacity) {
+      this.pendingWork = !0;
+      return;
+    }
+    let r;
+    try {
+      r = this.appendRange(n.data);
+    } catch {
+      this.compactionCount++, this.compact();
+      try {
+        r = this.appendRange(n.data);
+      } catch {
+        this.pendingWork = !0;
+        return;
+      }
+    }
+    this.envHandle = r, this.envSplatCount = n.data.count, n.lastUsed = e;
+  }
+  /** Ranks the env tile ahead of every LOD want in {@link flushClassicFetches}. */
+  enqueueEnvironmentFetch(e, t) {
+    e.has(t) || e.set(t, {
+      kind: "priority",
+      phase: "environment",
+      distance: 0,
+      level: 0,
+      inView: !0,
+      coverageGroup: -1,
+      leafStart: 0,
+      leafEnd: 0,
+      screenImportance: Number.NEGATIVE_INFINITY,
+      groupDistance: 0,
+      groupPending: 1,
+      groupInView: !0,
+      groupScreenImportance: Number.NEGATIVE_INFINITY,
+      groupFinest: !0,
+      groupId: "environment",
+      groupClass: 0
+    });
+  }
+  /**
+   * Page-table reschedule (`foveationMode: 'page-table'`): posts the camera to the
+   * worker, which owns the cache + traversal + pager and replies asynchronously
+   * 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");
+    const a = new Set(this.pageTableFetchPriority);
+    for (const r of this.scene.source.computeDesiredRuns(e, i, n))
+      a.add(r.file), this.requestChunk(r.file, "base");
+    for (const [r, l] of this.fetching)
+      l.kind !== "sweep" && !a.has(r) && !this.scene.pinnedFiles.has(r) && l.controller.abort();
+    if (!this.pageTableCacheAtLimit && this.sweepAllowed()) {
+      const r = Math.max(1, this.maxInflight - mt), l = this.scene.chunkUrls.length;
+      for (let c = 0; c < l && this.fetching.size < r; c++)
+        this.pageTableCachedFiles.has(c) || this.requestChunk(c, "sweep");
+    }
+    this.pageTableInFlight || (this.pageTableInFlight = !0, this.postToWorker({
+      type: "reschedule",
+      seq: ++this.pageTableSeq,
+      cameraLocal: [e.x, e.y, e.z],
+      cameraForward: [t.x, t.y, t.z],
+      ...this.pageTableFoveation,
+      // Spark's cut is `pixel_scale × lodScale ≤ limit`, and the traversal only
+      // ever sees one side of that - so scaling the limit down by `lodScale` is
+      // the same comparison, with no protocol change.
+      limit: this.pageTableLimit / this.lodScaleValue,
+      budget: this.pageTableDrawBudget
+    }));
+  }
+  /**
+   * Applies a paging plan from the worker to the slab - fast memcpy writes only,
+   * no traversal or gather on the main thread - then fetches the chunks the
+   * frontier wants next, and reschedules again if chunks are still streaming.
+   */
+  applyFrontierPlan(e) {
+    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; ) {
+      let g = 1;
+      for (; d + g < n.length && n[d + g] === n[d] + 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;
+    }
+    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 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(
+      `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);
+      this.setScreenRadiusBand(
+        this.frontierBandBase.min * d,
+        this.frontierBandBase.max * d
+      );
+    }
+    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]);
+    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");
+    (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;
+    this.pageTableCachedFiles.add(e);
+    const n = this.shBands > 0 ? t.shPacked : void 0;
+    this.postToWorker(
+      {
+        type: "chunk",
+        file: e,
+        count: t.count,
+        positions: t.positions,
+        colors: t.colors,
+        covariances: t.covariances,
+        childCount: i.childCount,
+        childStart: i.childStart,
+        size: i.size,
+        shBands: (n == null ? void 0 : n.bands) ?? 0,
+        ...n ? { shPacked: n.packed, shRange: n.range } : {}
+      },
+      [
+        t.positions.buffer,
+        t.colors.buffer,
+        t.covariances.buffer,
+        i.childCount.buffer,
+        i.childStart.buffer,
+        i.size.buffer,
+        ...n ? [n.packed.buffer] : []
+      ]
+    );
+  }
+  /** Parallel chunk fetches. HTTP/2 multiplexes them; on HTTP/1.1 the browser's
+   * 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;
+  }
+  /**
+   * Whether this mesh may run its speculative background sweep. A mesh with no
+   * weight is hidden or suspended; a mesh with no `fetchWeight` at all is a
+   * host that never asked for arbitration, and keeps the old behaviour.
+   */
+  /**
+   * Sets this mesh's share of the scene's fetch bandwidth, as
+   * {@link StreamedSplatMeshOptions.fetchWeight} does at load.
+   *
+   * The weight normally closes over the mesh itself (`() =>
+   * governor.weightOf(mesh)`), which a host cannot express until `load`
+   * resolves - hence a setter as well as an option. Pass `undefined` to go back
+   * to unarbitrated sweeping.
+   */
+  setFetchWeight(e) {
+    this.fetchWeight = e;
+  }
+  sweepAllowed() {
+    if (this.performanceProfile === "smooth") return !1;
+    if (this.fetchWeight === void 0) return !0;
+    const e = this.fetchWeight();
+    return Number.isFinite(e) && e > 0;
+  }
+  /** Aborts in-flight fetches of one kind; their slots return through `finally`. */
+  abortFetches(e) {
+    for (const t of this.fetching.values())
+      t.kind === e && t.controller.abort();
+  }
+  requestChunk(e, t, i) {
+    var l, c;
+    if (this.cache.has(e) || this.pageTableCachedFiles.has(e) || this.fetching.has(e) || this.fetching.size >= this.maxInflight || this.failedFiles.has(e)) return;
+    const n = this.retrying.get(e);
+    if (n && performance.now() < n.readyAt) return;
+    this.fetchCountsValue[t]++;
+    const a = this.scene.chunkUrls[e];
+    if (a === void 0) {
+      E(`StreamedSplatMesh: manifest references unknown chunk file #${e}.`), this.failedFiles.add(e);
+      return;
+    }
+    if (this.fetchHandle && !((l = this.fetchScheduler) != null && l.tryAcquire(this.fetchHandle, t))) return;
+    const r = new AbortController();
+    this.fetching.set(e, { controller: r, kind: t, classicWant: i }), this.loader.load(a, {
+      kind: this.scene.chunkKind,
+      signal: r.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;
+      if (f >= gt)
+        this.retrying.delete(e), this.failedFiles.add(e), E(
+          `StreamedSplatMesh: gave up on chunk #${e} (${a}) after ${f} attempts.`,
+          h
+        );
+      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;
+    });
+  }
+  /**
+   * Stores a decoded chunk while keeping {@link cacheBytesTotal} in step. The
+   * counter replaces a full-cache re-sum on every reschedule; every mutation
+   * 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 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(
+      ([n, a]) => a.lastUsed !== e && !this.scene.pinnedFiles.has(n) && !this.neededFiles.has(n)
+    ).sort((n, a) => n[1].lastUsed - a[1].lastUsed);
+    for (const [n, a] of i) {
+      if (t <= this.cpuCacheBytes) break;
+      this.cache.delete(n), this.cacheBytesTotal -= 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);
+}
+function yt(o, s, e) {
+  const t = o.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),
+    ...t ? {
+      shPacked: {
+        ...t,
+        packed: t.packed.subarray(
+          s * be(t.bands),
+          (s + 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;
+    if (!Number.isFinite(e) || e < 0)
+      throw new RangeError("BudgetGovernor hysteresis must be a non-negative finite number.");
+    this.hysteresis = e;
+  }
+  /** The shared budget currently being split across members. */
+  get totalBudget() {
+    return this.total;
+  }
+  /** Replaces the shared total and reallocates. */
+  setTotalBudget(s) {
+    const e = W(s);
+    e !== this.total && (this.total = e, this.reallocate());
+  }
+  /** Number of registered members. */
+  get size() {
+    return this.entries.size;
+  }
+  /**
+   * Adds a member and reallocates the shared budget. The member's current
+   * budget is remembered and restored when it leaves the governor.
+   *
+   * @param member - The mesh (or compatible object) to govern.
+   * @param options - `weight` (default `1`): the member's share is
+   * 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))
+      throw new Error("BudgetGovernor: member is already registered.");
+    const t = J(e.weight ?? 1);
+    this.entries.set(s, {
+      member: s,
+      weight: t,
+      applied: s.budget,
+      restoreBudget: s.budget
+    }), this.reallocate();
+  }
+  /**
+   * Removes a member, restores the budget it had when it registered, and
+   * 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());
+  }
+  /**
+   * 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());
+  }
+  /**
+   * Writes several weights, then reallocates **once**.
+   *
+   * Prefer this to a loop of {@link setWeight} whenever more than one weight
+   * changes together - as a camera-driven reweight does. Each reallocation
+   * pushes `setBudget` to every member, and for a streamed mesh that forces an
+   * LOD reschedule, so N separate calls cost N passes over the whole group to
+   * reach a state one pass would have produced.
+   *
+   * @param weights - `[member, weight]` pairs. Every member must be registered;
+   * unlisted members keep their current weight.
+   * @throws {Error} if any member is not registered - checked before anything
+   * 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)]
+    );
+    let t = !1;
+    for (const [i, n] of e)
+      i.weight !== n && (i.weight = n, t = !0);
+    t && this.reallocate();
+  }
+  /** The budget the governor last applied to a member, if registered. */
+  budgetOf(s) {
+    var e;
+    return (e = this.entries.get(s)) == null ? void 0 : e.applied;
+  }
+  /**
+   * Recomputes and applies every member's share. Called automatically by all
+   * mutators; call it manually only if a member's internal ceiling changed
+   * outside the governor's view.
+   */
+  reallocate() {
+    let s = [];
+    for (const t of this.entries.values())
+      t.weight === 0 ? this.applyTarget(t, Ct) : s.push(t);
+    let e = this.total;
+    for (; s.length > 0; ) {
+      const t = s.reduce((a, r) => a + r.weight, 0), i = [];
+      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);
+      }
+      if (i.length === 0) break;
+      e = Math.max(0, e - n), s = s.filter((a) => !i.includes(a));
+    }
+  }
+  /**
+   * Restores every member's pre-registration budget and empties the governor.
+   * The governor itself stays usable (dispose is just "unregister everyone").
+   */
+  dispose() {
+    for (const s of this.entries.values())
+      s.member.setBudget(s.restoreBudget);
+    this.entries.clear();
+  }
+  /** The entry for a registered member, or a thrown error naming the problem. */
+  entryOf(s) {
+    const e = this.entries.get(s);
+    if (e === void 0)
+      throw new Error("BudgetGovernor: member is not registered.");
+    return e;
+  }
+  /**
+   * 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)
+      return !1;
+    return s.applied = s.member.setBudget(e), s.applied < e;
+  }
+}
+function J(o) {
+  if (!Number.isFinite(o) || o < 0)
+    throw new RangeError(
+      "BudgetGovernor member weight must be a non-negative finite number (0 suspends the member)."
+    );
+  return o;
+}
+const we = new w.Vector3(), ye = new w.Matrix4(), Ce = new w.Frustum(), Z = new w.Box3(), z = new w.Sphere();
+class zt {
+  constructor(s = {}) {
+    u(this, "entries", /* @__PURE__ */ new Map());
+    u(this, "budgetGovernor");
+    u(this, "minIntervalMs");
+    u(this, "weightDeadband");
+    u(this, "falloff");
+    u(this, "offScreenWeight");
+    u(this, "minWeight");
+    u(this, "maxWeight");
+    u(this, "lastUpdateAt", -1 / 0);
+    /** Set by membership/priority changes: the next update ignores both damps. */
+    u(this, "forceNext", !0);
+    if (this.budgetGovernor = s.governor ?? new Tt(s), this.minIntervalMs = D(s.minIntervalMs ?? 250, "minIntervalMs"), this.weightDeadband = D(s.weightDeadband ?? 0.15, "weightDeadband"), this.falloff = U(s.falloff ?? 1, "falloff"), this.offScreenWeight = U(s.offScreenWeight ?? 0.25, "offScreenWeight"), this.minWeight = U(s.minWeight ?? 0.05, "minWeight"), this.maxWeight = U(s.maxWeight ?? 8, "maxWeight"), this.maxWeight < this.minWeight)
+      throw new RangeError("CameraBudgetGovernor maxWeight must be >= minWeight.");
+  }
+  /** The governor this drives; use it for fixed-weight members and diagnostics. */
+  get governor() {
+    return this.budgetGovernor;
+  }
+  /** The shared total being split, from the underlying governor. */
+  get totalBudget() {
+    return this.budgetGovernor.totalBudget;
+  }
+  /** Replaces the shared total (e.g. the presenting budget on `sessionstart`). */
+  setTotalBudget(s) {
+    this.budgetGovernor.setTotalBudget(s);
+  }
+  /** Number of camera-weighted members. */
+  get size() {
+    return this.entries.size;
+  }
+  /**
+   * Adds a member, registers it with the underlying governor, and forces a
+   * reweight on the next {@link update}.
+   *
+   * @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))
+      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;
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Changes a member's priority tier. Takes effect on the next {@link update},
+   * which is forced - a deliberate focus change should not wait out the
+   * interval or be swallowed by the dead-band.
+   *
+   * @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);
+    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);
+  }
+  /**
+   * Recomputes every member's weight from the camera and applies them in one
+   * batch. Call once per frame, after the scene graph is up to date.
+   *
+   * Needs no renderer: weights are a ratio, so viewport size cancels out.
+   *
+   * Skipped - returning `false` - when called inside `minIntervalMs` of the
+   * last reweight, or when no member's weight moved by more than
+   * `weightDeadband`. Membership and priority changes force it through both.
+   *
+   * @param camera - The view detail should follow. In an immersive session pass
+   * the head/`ArrayCamera`, not the idle application camera.
+   * @param now - Timestamp in ms on the `performance.now` clock; defaults to it.
+   * @returns whether weights were reapplied.
+   */
+  update(s, e = performance.now()) {
+    if (this.entries.size === 0) return !1;
+    const t = this.forceNext;
+    if (!t && e - this.lastUpdateAt < this.minIntervalMs) return !1;
+    s.updateMatrixWorld(), s.getWorldPosition(we), ye.multiplyMatrices(s.projectionMatrix, s.matrixWorldInverse), Ce.setFromProjectionMatrix(ye);
+    const i = [];
+    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);
+    }
+    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);
+    }
+    return this.lastUpdateAt = e, this.forceNext = !1, !0;
+  }
+  /** The weight currently written for a member, if registered here. */
+  weightOf(s) {
+    var e;
+    return (e = this.entries.get(s)) == null ? void 0 : e.applied;
+  }
+  /** The budget the underlying governor last applied to a member. */
+  budgetOf(s) {
+    return this.budgetGovernor.budgetOf(s);
+  }
+  /**
+   * Unregisters every member, restoring the budget each had when it joined.
+   * The helper stays usable afterwards. A governor passed in by the host keeps
+   * any members the host registered on it directly.
+   */
+  dispose() {
+    for (const s of [...this.entries.keys()]) this.budgetGovernor.unregister(s);
+    this.entries.clear(), this.lastUpdateAt = -1 / 0, this.forceNext = !0;
+  }
+  /**
+   * A member's weight: `priority × clamp((radius / distance) ^ falloff) ×
+   * offScreen`.
+   *
+   * `radius / distance` is the tangent of the member's half angular size - the
+   * same `size / distance` measure Spark's `pixel_scale` traversal ranks nodes
+   * by, one level up at whole-mesh granularity. Distance is measured to the
+   * bounding sphere's *surface*, so a large mesh is not penalized for having a
+   * 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;
+    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;
+  }
+  /** 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;
+  }
+}
+function It(o, s, e) {
+  return Math.min(e, Math.max(s, o));
+}
+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 U(o, s) {
+  if (!Number.isFinite(o) || o <= 0)
+    throw new RangeError(`CameraBudgetGovernor ${s} must be a positive finite number.`);
+  return o;
+}
+const Rt = 16, Mt = 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);
+    this.maxGlobalInflight = Math.max(
+      1,
+      Math.floor(s.maxGlobalInflight ?? Rt)
+    ), this.perMeshFloor = Math.max(0, Math.floor(s.perMeshFloor ?? Mt));
+  }
+  /** Total slots granted and not yet released. */
+  get inflight() {
+    return this.inflightCount;
+  }
+  /** Meshes currently registered. */
+  get clientCount() {
+    return this.entries.size;
+  }
+  register(s) {
+    const e = { client: s, held: 0, demanding: !1, live: !0 };
+    return this.entries.add(e), e;
+  }
+  /**
+   * Drops a mesh. Slots it still holds are released here: a disposing mesh
+   * aborts its fetches, and those aborts land after the handle is gone.
+   */
+  unregister(s) {
+    const e = s;
+    this.entries.delete(e) && (e.live = !1, e.held > 0 && (this.inflightCount -= e.held, e.held = 0, this.wake()));
+  }
+  /**
+   * Grants a fetch slot, or denies and remembers the demand.
+   *
+   * A denial is not a failure and must not feed a mesh's retry backoff - the
+   * 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;
+    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);
+  }
+  /**
+   * 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;
+    e.held <= 0 || (e.held--, this.inflightCount--, this.wake());
+  }
+  /**
+   * Re-examines weights after the camera moved. Call it once per frame, right
+   * after the budget governor's own update.
+   *
+   * Meshes that just lost all weight shed their pre-warming sweeps, so a focus
+   * change frees the pipe now rather than when a dozen far requests happen to
+   * finish.
+   */
+  weightsChanged() {
+    if (!this.disposed) {
+      for (const s of this.entries)
+        s.held > 0 && H(s.client.weight()) <= 0 && s.client.shedFetches("sweep");
+      this.wake();
+    }
+  }
+  /**
+   * Releases every registration. Meshes are not disposed - the scheduler is
+   * shared and does not own them, exactly as a shared `SplatPool` does not own
+   * its meshes.
+   */
+  dispose() {
+    this.disposed = !0;
+    for (const s of this.entries)
+      s.live = !1, s.held = 0, s.demanding = !1;
+    this.entries.clear(), this.inflightCount = 0;
+  }
+  /**
+   * The most slots this mesh may hold: its weight-proportional share of the
+   * *whole* pipe, floored so it can always trickle and capped so its siblings
+   * can always reach their own floors.
+   *
+   * This is a ceiling, not a reservation. The global cap does the real
+   * limiting, so a heavy mesh can use capacity its idle siblings are leaving on
+   * the table, while a far mesh's ceiling stays at its floor however early it
+   * asks - which is what keeps the first mesh to reschedule from taking the
+   * pipe and holding it. Dividing the *remainder* after every participant's
+   * floor instead would invert the whole point on a large scene: thirteen
+   * additional meshes and a main at floor 1 consume a 16-slot pipe entirely, leaving the
+   * focused mesh a smaller share than the far ones it is competing with.
+   *
+   * 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);
+    }
+    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));
+  }
+  /** 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;
+    for (const t of this.entries) {
+      if (!t.demanding) continue;
+      const i = H(t.client.weight());
+      i > e && (s = t, e = i);
+    }
+    s && (s.demanding = !1, s.client.onSlotAvailable());
+  }
+}
+function H(o) {
+  return Number.isFinite(o) && o > 0 ? o : 0;
+}
+const Ft = 32 * 1024 * 1024, Bt = 250, 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)
+      throw new RangeError("Chunk cache totalBytes must be a positive finite number.");
+    this.totalBytesValue = Math.floor(s.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);
+  }
+  /** Bytes shared across every registered mesh. */
+  get totalBytes() {
+    return this.totalBytesValue;
+  }
+  /**
+   * 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)
+      throw new RangeError("Chunk cache totalBytes must be a positive finite number.");
+    const e = Math.floor(s);
+    e !== this.totalBytesValue && (this.totalBytesValue = e, this.allocate());
+  }
+  /** Meshes currently registered. */
+  get clientCount() {
+    return this.entries.size;
+  }
+  /**
+   * 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 };
+    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;
+    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;
+    return e.live ? e.allowance : 0;
+  }
+  /**
+   * Re-splits after the camera moved. Call it once per frame, right beside
+   * {@link ChunkFetchScheduler.weightsChanged} - the two read the same weights,
+   * so cache and network follow the same measure.
+   *
+   * 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());
+  }
+  /**
+   * Releases every registration. Meshes are not disposed - the budget is shared
+   * and does not own them, exactly as a shared `SplatPool` does not own its
+   * meshes.
+   */
+  dispose() {
+    this.disposed = !0;
+    for (const s of this.entries)
+      s.live = !1, s.allowance = 0;
+    this.entries.clear();
+  }
+  /**
+   * Cap-aware waterfill: weight-proportional shares, floored so every mesh can
+   * hold its coarse base, clamped at each mesh's `ceilingBytes`, and the surplus
+   * from clamped meshes redistributed over the rest until it settles.
+   *
+   * The invariant callers depend on is `Σ allowance <= totalBytes`. It holds in
+   * every branch, including the degenerate one where the floors alone exceed
+   * the envelope - there the floors are scaled down proportionally rather than
+   * silently overcommitting, because a budget that can be exceeded by
+   * registering more meshes is the bug this class exists to fix.
+   */
+  allocate(s = {}) {
+    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 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);
+      }
+      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 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));
+    }
+  }
+  /** 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;
+  }
+}
+function Te(o) {
+  return Number.isFinite(o) && o > 0 ? o : 0;
+}
+function kt(o) {
+  return Number.isFinite(o) && o > 0 ? Math.floor(o) : Number.MAX_SAFE_INTEGER;
+}
+export {
+  Tt as BudgetGovernor,
+  zt as CameraBudgetGovernor,
+  Ht as ChunkCacheBudget,
+  Ut as ChunkFetchScheduler,
+  q as SplatLoadError,
+  Y as StreamedSplatMesh,
+  ot as createLocalDataset,
+  nt as httpDatasetSource,
+  N as isAbortError,
+  Be as resolveCpuCacheBytes
+};
+//# sourceMappingURL=streaming.js.map