@voluma/vlam 0.2.4 → 0.3.0

package/dist/splat-mesh-aQdcWA6v.js

@@ -0,0 +1,1942 @@
+var pt = Object.defineProperty;
+var ft = (g, u, e) => u in g ? pt(g, u, { enumerable: !0, configurable: !0, writable: !0, value: e }) : g[u] = e;
+var o = (g, u, e) => ft(g, typeof u != "symbol" ? u + "" : u, e);
+import { r as Y, M as gt, a as mt } from "./splat-mesh-types-BZIko-_9.js";
+import * as d from "three/webgpu";
+import { uniform as b } from "three/tsl";
+import { z as wt, e as xt, m as St, b as vt, D as yt, c as Rt, A as Z, B as bt, E as Tt, W as At, F as K, G as Q, H as J, I as Mt, i as It, j as kt, y as Pt, n as Ct, r as Ut, J as z, C as tt, f as Dt } from "./relighting-CSQF3UcL.js";
+import { l as et, w as O } from "./logging-BfPdd7NJ.js";
+import { d as Bt } from "./splat-budget-DuVZspPQ.js";
+import { e as G } from "./half-float-Cs4FDq8Q.js";
+import { a as Et, r as Wt, n as Lt } from "./sh-pack-D5wAe5gg.js";
+function Ft() {
+  return new d.Matrix4().makeRotationX(Math.PI);
+}
+function Vt(g) {
+  switch (g) {
+    case "ply":
+    case "splat":
+    case "ksplat":
+    case "sog":
+    case "rad":
+    case "streamed-sog":
+      return Ft();
+    case "spz":
+    case "lcc":
+    case "lcc2":
+    case void 0:
+      return null;
+  }
+}
+const lt = `let w = new Float32Array(0), x = new Float32Array(0);
+const f = new Uint32Array(65536);
+let E = 0, S = new Uint32Array(0), M = new Float32Array(0), I = new Uint32Array(0), R = new Uint32Array(0), Y = new Uint32Array(0);
+function j(e) {
+  e <= E || (E = e, S = new Uint32Array(e), M = new Float32Array(e), I = new Uint32Array(e), R = new Uint32Array(e), Y = new Uint32Array(e));
+}
+function q(e, r, n) {
+  const D = e[2], K = e[6], _ = e[10], k = e[14];
+  let c = 0;
+  for (let t = 0; t < r.length; t += 2) c += r[t + 1];
+  j(c);
+  let d = 1 / 0, F = -1 / 0, X = 0;
+  for (let t = 0; t < r.length; t += 2) {
+    const i = r[t], o = i + r[t + 1];
+    for (let s = i; s < o; s++) {
+      const a = s * 4, h = x[s], l = n ? h * 16 : 0, u = w[a], U = w[a + 1], g = w[a + 2], B = n ? n[l] * u + n[l + 4] * U + n[l + 8] * g + n[l + 12] : u, T = n ? n[l + 1] * u + n[l + 5] * U + n[l + 9] * g + n[l + 13] : U, Z = n ? n[l + 2] * u + n[l + 6] * U + n[l + 10] * g + n[l + 14] : g, A = D * B + K * T + _ * Z + k;
+      S[X] = s, M[X] = A, X++, A < d && (d = A), A > F && (F = A);
+    }
+  }
+  const z = 16777215 / (F - d || 1);
+  let y = R;
+  for (let t = 0; t < c; t++)
+    I[t] = (M[t] - d) * z, y[t] = t;
+  let p = Y;
+  for (let t = 0; t < 24; t += 16) {
+    f.fill(0);
+    for (let o = 0; o < c; o++) {
+      const s = I[y[o]] >>> t & 65535;
+      f[s] = f[s] + 1;
+    }
+    let i = 0;
+    for (let o = 0; o < 65536; o++) {
+      const s = f[o];
+      f[o] = i, i += s;
+    }
+    for (let o = 0; o < c; o++) {
+      const s = y[o], a = I[s] >>> t & 65535, h = f[a];
+      p[h] = s, f[a] = h + 1;
+    }
+    [y, p] = [p, y];
+  }
+  R = y, Y = p;
+  const b = new Uint32Array(c);
+  for (let t = 0; t < c; t++) b[t] = S[y[t]];
+  return b;
+}
+self.onmessage = (e) => {
+  const r = e.data;
+  if (r.type === "init") {
+    w = new Float32Array(r.capacity * 4), x = new Float32Array(r.capacity);
+    return;
+  }
+  if (r.type === "write") {
+    w.set(r.centers, r.start * 4), r.sourceIds && x.set(r.sourceIds, r.start);
+    return;
+  }
+  const n = q(r.modelView, r.spans, r.matrices), D = { type: "order", order: n };
+  self.postMessage(D, [n.buffer]);
+};
+//# sourceMappingURL=sort-worker-CDRn-GLW.js.map
+`, it = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", lt], { type: "text/javascript;charset=utf-8" });
+function _t(g) {
+  let u;
+  try {
+    if (u = it && (self.URL || self.webkitURL).createObjectURL(it), !u) throw "";
+    const e = new Worker(u, {
+      type: "module",
+      name: g == null ? void 0 : g.name
+    });
+    return e.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(u);
+    }), e;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(lt),
+      {
+        type: "module",
+        name: g == null ? void 0 : g.name
+      }
+    );
+  }
+}
+class qt {
+  constructor(u) {
+    o(this, "kind", "worker");
+    o(this, "worker");
+    o(this, "splatIndexAttribute");
+    o(this, "host");
+    o(this, "inFlight", !1);
+    /** Set by {@link dispose}; drops any already-delivered order message. */
+    o(this, "disposed", !1);
+    /** The active spans the in-flight sort was computed against. */
+    o(this, "sentSpans", null);
+    o(this, "submittedCount", 0);
+    o(this, "completedCount", 0);
+    o(this, "lastSubmittedAt", -1 / 0);
+    o(this, "lastCompletedAt", -1 / 0);
+    o(this, "lastLatencyMs", Number.NaN);
+    this.host = u, this.splatIndexAttribute = u.splatIndexAttribute, this.worker = new _t(), this.worker.onmessage = (t) => {
+      this.applyOrder(t.data.order);
+    }, this.worker.onerror = (t) => {
+      et("sort worker error - retrying on a later frame.", t.message), this.inFlight = !1;
+    }, this.worker.onmessageerror = () => {
+      et("sort worker message deserialization failed."), this.inFlight = !1;
+    };
+    const e = { type: "init", capacity: u.capacity };
+    this.worker.postMessage(e), this.pushCenters([{ start: 0, count: Math.ceil(u.capacity / u.rowWidth) }]);
+  }
+  sort(u, e, t) {
+    if (this.disposed || this.inFlight) return !1;
+    this.inFlight = !0, this.submittedCount++, this.lastSubmittedAt = performance.now(), this.pushCenters(this.host.takeDirtyRows());
+    const i = this.host.getActiveSpans();
+    this.sentSpans = i;
+    const s = {
+      type: "sort",
+      modelView: new Float32Array(u.elements),
+      spans: i,
+      matrices: this.host.perSource ? new Float32Array(this.host.perSource.matrices) : void 0
+    };
+    return this.worker.postMessage(s), !0;
+  }
+  /** Internal timing diagnostics used by the demo's opt-in XR A/B harness. */
+  snapshot() {
+    return {
+      submittedCount: this.submittedCount,
+      completedCount: this.completedCount,
+      lastSubmittedAt: this.lastSubmittedAt,
+      lastCompletedAt: this.lastCompletedAt,
+      lastLatencyMs: this.lastLatencyMs
+    };
+  }
+  dispose() {
+    this.disposed || (this.disposed = !0, this.worker.terminate());
+  }
+  /** Sends written pool rows to keep the worker's centers mirror current. */
+  pushCenters(u) {
+    var t;
+    const e = this.host.rowWidth;
+    for (const i of u) {
+      const s = this.host.centers.slice(
+        i.start * e * 4,
+        (i.start + i.count) * e * 4
+      ), r = i.start * e, n = i.count * e, a = (t = this.host.perSource) == null ? void 0 : t.sourceIds.slice(r, r + n), c = { type: "write", start: r, centers: s, sourceIds: a };
+      this.worker.postMessage(c, [s.buffer]);
+    }
+  }
+  applyOrder(u) {
+    var s, r;
+    if (this.inFlight = !1, this.completedCount++, this.lastCompletedAt = performance.now(), this.lastLatencyMs = this.lastCompletedAt - this.lastSubmittedAt, this.disposed) return;
+    const e = this.host.getActiveSpans(), t = this.sentSpans;
+    if (this.sentSpans = null, !t || t.length !== e.length) return;
+    for (let n = 0; n < t.length; n++)
+      if (t[n] !== e[n]) return;
+    const i = this.splatIndexAttribute.array;
+    for (let n = 0; n < u.length; n++)
+      i[n] = u[n];
+    this.splatIndexAttribute.addUpdateRange(0, u.length), this.splatIndexAttribute.needsUpdate = !0, (r = (s = this.host).onOrderApplied) == null || r.call(s);
+  }
+}
+const zt = (1 << 24) - 1, st = new d.Vector2(), V = new d.Raycaster(), rt = new d.Vector3();
+function Ot(g, u, e) {
+  return ((g & 255) << 16 | (u & 255) << 8 | e & 255) / zt;
+}
+function Gt(g, u, e) {
+  return u + g * (e - u);
+}
+function Ht(g, u, e, t, i) {
+  st.set(g, u), V.setFromCamera(st, t), rt.copy(V.ray.direction).transformDirection(t.matrixWorldInverse);
+  const s = e / -rt.z;
+  return i.copy(V.ray.origin).addScaledVector(V.ray.direction, s), { point: i, distance: i.distanceTo(V.ray.origin) };
+}
+class Nt {
+  constructor(u) {
+    /** Alpha below which a splat is transparent enough to pick through. */
+    o(this, "alphaThreshold", b(0.1));
+    /** Camera planes for the pick material's depth encoding. */
+    o(this, "near", b(0.1));
+    o(this, "far", b(1e3));
+    o(this, "material", null);
+    o(this, "proxy", null);
+    o(this, "target", null);
+    /** Reused sub-frustum camera; preserves the caller's concrete camera type. */
+    o(this, "pickCamera", null);
+    o(this, "scene", new d.Scene());
+    /** Serializes picks: they share one render target and one renderer. */
+    o(this, "queue", Promise.resolve());
+    o(this, "point", new d.Vector3());
+    o(this, "savedClearColor", new d.Color());
+    this.host = u;
+  }
+  /** The pick uniforms the material graph binds. */
+  get uniforms() {
+    return { alphaThreshold: this.alphaThreshold, near: this.near, far: this.far };
+  }
+  pick(u, e, t, i) {
+    const s = this.queue.then(() => this.run(u, e, t, i));
+    return this.queue = s.then(
+      () => {
+      },
+      () => {
+      }
+    ), s;
+  }
+  /** Rebuilds the pick graph after a settings change. No-op before the first pick. */
+  rebuildMaterial() {
+    this.material && this.host.applyPickGraph(this.material);
+  }
+  /** Flags the pick graph for recompile (e.g. the modifier list changed). */
+  markNeedsUpdate() {
+    this.material && (this.material.needsUpdate = !0);
+  }
+  dispose() {
+    var u, e;
+    (u = this.material) == null || u.dispose(), this.material = null, this.scene.clear(), this.proxy = null, (e = this.target) == null || e.dispose(), this.target = null, this.pickCamera = null;
+  }
+  async run(u, e, t, i) {
+    if (this.host.isDisposed() || this.host.getActiveCount() === 0 || u.x < -1 || u.x > 1 || u.y < -1 || u.y > 1) return null;
+    if (wt(e))
+      throw new Error(
+        "SplatMesh.pick: an XR array camera has no single frustum to pick through. Pass one eye (renderer.xr.getCamera().cameras[i]) or a mono camera, and give `ndc` in that eye’s viewport."
+      );
+    e.updateMatrixWorld(!0), this.host.updateWorldMatrix(), this.host.prepare(e, t);
+    const s = Math.max(1, Math.floor(this.host.getViewportSize().x)), r = Math.max(1, Math.floor(this.host.getViewportSize().y)), n = Math.floor((u.x * 0.5 + 0.5) * s), a = Math.floor((u.y * 0.5 + 0.5) * r);
+    if (n < 0 || a < 0 || n >= s || a >= r) return null;
+    this.ensureResources(e);
+    const c = this.target, h = this.proxy, l = this.pickCamera;
+    this.cropCameraToPixel(l, e, s, r, n, a), this.host.setView(l, 1, 1);
+    const f = "near" in e && typeof e.near == "number" ? e.near : 0.1, x = "far" in e && typeof e.far == "number" ? e.far : 1e3;
+    this.near.value = f, this.far.value = x, this.alphaThreshold.value = (i == null ? void 0 : i.alphaThreshold) !== void 0 ? i.alphaThreshold : 0.1;
+    const p = this.host.mesh, w = t.getRenderTarget(), m = t.getScissorTest();
+    t.getClearColor(this.savedClearColor);
+    const S = t.getClearAlpha(), A = t.autoClear;
+    h.matrix.copy(p.matrixWorld), h.matrixWorld.copy(p.matrixWorld), h.visible = this.host.getPickVisible(), h.layers.mask = p.layers.mask, h.renderOrder = p.renderOrder, c.viewport.set(0, 0, 1, 1), c.scissor.set(0, 0, 1, 1);
+    const R = (() => {
+      try {
+        return t.setRenderTarget(c), t.setScissorTest(!1), t.setClearColor(0, 0), t.autoClear = !0, t.clear(), t.setScissorTest(!0), t.autoClear = !1, t.render(this.scene, l), t.readRenderTargetPixelsAsync(c, 0, 0, 1, 1);
+      } finally {
+        this.host.setView(e, s, r), t.setRenderTarget(w), t.setScissorTest(m), t.setClearColor(this.savedClearColor, S), t.autoClear = A;
+      }
+    })();
+    let y;
+    try {
+      y = await R;
+    } catch (L) {
+      if (this.host.isDisposed()) return null;
+      throw L;
+    }
+    if (this.host.isDisposed()) return null;
+    const M = y[0], U = y[1], I = y[2];
+    if (y[3] === 0) return null;
+    const B = Gt(Ot(M, U, I), f, x), { point: E, distance: W } = Ht(u.x, u.y, B, e, this.point);
+    return { point: E.clone(), distance: W };
+  }
+  ensureResources(u) {
+    this.target === null && (this.target = new d.RenderTarget(1, 1, {
+      format: d.RGBAFormat,
+      type: d.UnsignedByteType,
+      depthBuffer: !0,
+      stencilBuffer: !1
+    })), this.material === null && (this.material = new d.NodeMaterial(), this.host.applyPickGraph(this.material), this.proxy = new d.Mesh(this.host.mesh.geometry, this.material), this.proxy.matrixAutoUpdate = !1, this.proxy.frustumCulled = !1, this.scene.add(this.proxy)), (this.pickCamera === null || this.pickCamera.constructor !== u.constructor) && (this.pickCamera = u.clone());
+  }
+  /** Maps one original framebuffer pixel onto the complete 1×1 pick target. */
+  cropCameraToPixel(u, e, t, i, s, r) {
+    u.copy(e);
+    const n = u.projectionMatrix, a = n.elements, c = 2 * s + 1 - t, h = 2 * r + 1 - i;
+    for (let l = 0; l < 4; l++) {
+      const f = a[l * 4 + 3];
+      a[l * 4] = a[l * 4] * t - c * f, a[l * 4 + 1] = a[l * 4 + 1] * i - h * f;
+    }
+    u.projectionMatrixInverse.copy(n).invert();
+  }
+}
+const Xt = 1024, jt = 1 << 21;
+class $t {
+  /**
+   * @param centers - The pool's CPU centers (stride 4: x,y,z,_ per splat).
+   * @param poolIndices - The pool indices to index (e.g. the active list).
+   * @param count - How many entries of `poolIndices` are valid.
+   */
+  constructor(u, e, t) {
+    /** Populated-region minimum corner (local space). */
+    o(this, "min", new Float64Array(3));
+    /** Per-axis cell size (local units). */
+    o(this, "cellSize", new Float64Array(3));
+    /** Per-axis cell counts. */
+    o(this, "dims", new Int32Array(3));
+    /** CSR cell offsets: cell c owns `items[start[c] .. start[c+1])`. */
+    o(this, "cellStart");
+    /** Pool indices, bucketed by cell. */
+    o(this, "items");
+    /** Pool centers array this grid points into (RGBA stride 4). */
+    o(this, "centers");
+    o(this, "count");
+    if (this.centers = u, this.count = t, t === 0) {
+      this.dims.set([1, 1, 1]), this.cellSize.set([1, 1, 1]), this.cellStart = new Int32Array(2), this.items = new Uint32Array(0);
+      return;
+    }
+    const i = [1 / 0, 1 / 0, 1 / 0], s = [-1 / 0, -1 / 0, -1 / 0];
+    for (let p = 0; p < t; p++) {
+      const w = e[p] * 4;
+      for (let m = 0; m < 3; m++) {
+        const S = u[w + m];
+        S < i[m] && (i[m] = S), S > s[m] && (s[m] = S);
+      }
+    }
+    const r = [
+      s[0] - i[0],
+      s[1] - i[1],
+      s[2] - i[2]
+    ], n = r.filter((p) => p > 0), a = n.reduce((p, w) => p * w, 1);
+    let c = n.length > 0 ? Math.pow(a / t, 1 / n.length) : 1;
+    (!(c > 0) || !Number.isFinite(c)) && (c = 1);
+    const h = (p) => {
+      for (let w = 0; w < 3; w++) {
+        const m = r[w];
+        this.dims[w] = m > 0 ? Math.max(1, Math.min(Xt, Math.round(m / p) || 1)) : 1, this.cellSize[w] = this.dims[w] > 0 && m / this.dims[w] || 1, this.min[w] = i[w];
+      }
+    };
+    for (h(c); this.dims[0] * this.dims[1] * this.dims[2] > jt; )
+      c *= 1.5, h(c);
+    const l = this.dims[0] * this.dims[1] * this.dims[2], f = new Int32Array(l + 1);
+    for (let p = 0; p < t; p++) f[this.cellOf(e[p]) + 1]++;
+    for (let p = 0; p < l; p++) f[p + 1] += f[p];
+    this.cellStart = f, this.items = new Uint32Array(t);
+    const x = Int32Array.from(f.subarray(0, l));
+    for (let p = 0; p < t; p++) {
+      const w = e[p];
+      this.items[x[this.cellOf(w)]++] = w;
+    }
+  }
+  /** The cell index of pool splat `p`, clamped into range. */
+  cellOf(u) {
+    const e = u * 4, t = this.axisCell(0, this.centers[e]), i = this.axisCell(1, this.centers[e + 1]);
+    return (this.axisCell(2, this.centers[e + 2]) * this.dims[1] + i) * this.dims[0] + t;
+  }
+  axisCell(u, e) {
+    const t = Math.floor((e - this.min[u]) / this.cellSize[u]);
+    return Math.max(0, Math.min(this.dims[u] - 1, t));
+  }
+  /**
+   * Visits every indexed splat within `radius` (local units) of the local
+   * point, calling `visit(poolIndex, distanceSq)`. Cells are pruned by their
+   * axis span and each candidate is distance-filtered here, so the callback
+   * only ever sees splats truly within the radius.
+   */
+  forEachWithin(u, e, t, i, s) {
+    if (this.count === 0 || i < 0) return;
+    const r = i * i, n = [0, 0, 0], a = [0, 0, 0], c = [u, e, t];
+    for (let h = 0; h < 3; h++) {
+      const l = Math.ceil(i / this.cellSize[h]), f = this.axisCell(h, c[h]);
+      n[h] = Math.max(0, f - l), a[h] = Math.min(this.dims[h] - 1, f + l);
+    }
+    for (let h = n[2]; h <= a[2]; h++)
+      for (let l = n[1]; l <= a[1]; l++) {
+        const f = (h * this.dims[1] + l) * this.dims[0], x = this.cellStart[f + n[0]], p = this.cellStart[f + a[0] + 1];
+        for (let w = x; w < p; w++) {
+          const m = this.items[w], S = m * 4, A = this.centers[S] - u, R = this.centers[S + 1] - e, y = this.centers[S + 2] - t, M = A * A + R * R + y * y;
+          M <= r && s(m, M);
+        }
+      }
+  }
+  /**
+   * The nearest indexed splat to the local point within `radius`, or null.
+   * Returns its pool index and squared local distance.
+   */
+  nearest(u, e, t, i) {
+    let s = -1, r = 1 / 0;
+    return this.forEachWithin(u, e, t, i, (n, a) => {
+      a < r && (r = a, s = n);
+    }), s < 0 ? null : { poolIndex: s, distSq: r };
+  }
+}
+const Yt = 4, v = class v extends d.Mesh {
+  constructor(e, t = {}) {
+    var W, L;
+    const i = bt(t.sortIntervalMs), s = ((W = Bt()) == null ? void 0 : W.isMobile) === !0, r = ct(t.maxStdDev) ?? 3, n = Jt(t.minSplatSizePx) ?? (s ? 1.5 : 0), a = !("capacity" in e), c = a ? e.count : e.capacity;
+    if (c <= 0) throw new Error("SplatMesh capacity must be positive.");
+    const h = (t.shBands ?? (Y(t.performanceProfile) === "smooth" ? 0 : gt)) !== 0, l = a ? h ? ((L = e.shPacked) == null ? void 0 : L.bands) ?? 0 : 0 : t.shBands ?? 0, f = t.pool, x = () => new Dt({
+      capacity: c,
+      floatTextures: t.poolFloatTextures,
+      packedShBands: l,
+      packedShTextureCount: l === 0 ? 0 : Math.ceil(J(l) / 4),
+      ...t.maxTextureSize === void 0 ? {} : { maxTextureSize: t.maxTextureSize }
+    }), p = f !== void 0 && l !== f.packedShBands;
+    p && O(
+      `a mesh with shBands ${l} cannot share a pool built for ${f == null ? void 0 : f.packedShBands}; it allocated its own pool instead.`
+    );
+    const w = f === void 0 || p, m = w ? x() : f, S = Math.min(
+      m.capacity,
+      Math.ceil(c / v.DATA_TEXTURE_WIDTH) * v.DATA_TEXTURE_WIDTH
+    ), A = m.centersTexture, R = m.colorsTexture, y = m.covarianceATexture, M = m.covarianceBTexture, U = a && e.sh && h ? Tt(
+      e.sh.palette,
+      e.sh.paletteWidth,
+      e.sh.paletteHeight,
+      d.FloatType
+    ) : null, I = m.shPackedTextures, D = new d.InstancedBufferGeometry();
+    D.setIndex([0, 1, 2, 0, 2, 3]), D.setAttribute(
+      "position",
+      new d.BufferAttribute(new Float32Array([-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0]), 3)
+    );
+    const B = new Float32Array(S);
+    for (let C = 0; C < S; C++) B[C] = C;
+    const E = new d.StorageInstancedBufferAttribute(B, 1);
+    D.setAttribute("splatIndex", E), D.instanceCount = 0;
+    super(D, new d.NodeMaterial());
+    /**
+     * The storage this mesh draws from. Held rather than inlined because a
+     * splat's draw identity is already independent of its pool slot (`splatIndex`
+     * indirects every instance), so the pool is a separable concern - see
+     * {@link SplatPool}.
+     */
+    o(this, "pool");
+    /** False when the pool was supplied by the caller, and so outlives this mesh. */
+    o(this, "ownsPool");
+    o(this, "splatIndexAttribute");
+    o(this, "sourceIndexAttribute");
+    o(this, "dataTextures");
+    /** True when constructed from a complete SplatData (single fixed range). */
+    o(this, "isStatic");
+    /** Constructor-created range, retained for static in-place LOD replacement. */
+    o(this, "staticRange");
+    o(this, "shEnabled");
+    /**
+     * Dequantization range for the packed SH, shared by every coefficient.
+     * Uniforms rather than constants: the first chunk to arrive supplies it,
+     * long after the material is built.
+     */
+    o(this, "shRange");
+    /** Set once the first packed-SH chunk has supplied {@link shRange}. */
+    o(this, "shRangeSet", !1);
+    /** Whether SH-less rows were neutral-filled before the scene range locked. */
+    o(this, "wrotePreLockNeutralSh", !1);
+    o(this, "ranges", /* @__PURE__ */ new Map());
+    o(this, "activeCount", 0);
+    /**
+     * Bumped whenever the resident splat set or its positions change (activate,
+     * deactivate, compact) - the signal the lazy spatial-query grid rebuilds on.
+     * A depth re-sort reorders the active list but changes neither, so it does
+     * not bump this. See {@link queryNearest}.
+     */
+    o(this, "queryEpoch", 0);
+    o(this, "queryGrid", null);
+    o(this, "queryGridEpoch", -1);
+    /**
+     * True when the shared depth-order buffer holds a *secondary* view's order
+     * (left by {@link renderView}), so the next primary {@link update} must
+     * re-sort even if its camera has not moved. See {@link renderView} (M10).
+     */
+    o(this, "orderIsForeign", !1);
+    /**
+     * True while the draw list holds a CPU-worker depth permutation rather than
+     * the identity active order. Active-list mutations must then resync the
+     * whole drawn prefix instead of patching slots: patching a *permutation*
+     * with identity active-list values creates duplicates and drops live splats
+     * for every frame until the worker's next order lands (the WebGL2 streamed
+     * flicker, ROADMAP L5).
+     */
+    o(this, "drawListSorted", !1);
+    /** CPU timings from the most recent render-preparation update (reset in place per frame). */
+    o(this, "updateTimings", {
+      activeListMs: 0,
+      uploadMs: 0,
+      sortSubmitMs: 0,
+      stagingTextureAllocations: 0,
+      activeListUpdateRanges: 0
+    });
+    // Protected so a unified {@link MergedSplatMesh} subclass can substitute a
+    // world-space sort bound (see {@link refreshSortBounds}).
+    o(this, "localBounds", new d.Box3().makeEmpty());
+    o(this, "boundingSphereLocal", new d.Sphere());
+    o(this, "boundsDirty", !0);
+    /** Cached {@link getUnifiedSourceView} result; see the invalidation checks there. */
+    o(this, "cachedUnifiedView", null);
+    o(this, "cachedUnifiedViewMatrixWorld", new d.Matrix4().makeScale(0, 0, 0));
+    o(this, "cachedUnifiedViewLocalBounds", new d.Sphere());
+    o(this, "cachedUnifiedViewWorldBounds", new d.Sphere());
+    /** Row spans written since the last flush, awaiting GPU upload. */
+    o(this, "pendingUploadRows", []);
+    /** Row spans awaiting mirroring to the CPU sort worker (WebGL2 path). */
+    o(this, "workerDirtyRows", []);
+    /** Persistent copy sources avoid allocating four temporary textures per upload region. */
+    o(this, "uploadStaging", /* @__PURE__ */ new Map());
+    /** Reusable float→half encode buffers keyed like {@link uploadStaging}. */
+    o(this, "halfEncodeBuffers", /* @__PURE__ */ new Map());
+    /** Opt-in per-splat channels by name; see {@link defineChannel}. */
+    o(this, "channels", /* @__PURE__ */ new Map());
+    /** Created on the first update, when the renderer backend is known. */
+    o(this, "sorter", null);
+    /**
+     * Set by a unified {@link MergedSplatMesh} subclass before the first sort: makes
+     * the WebGPU sorter transform each splat's center to world space by its
+     * source's matrix before measuring depth. `null` for an ordinary mesh, whose
+     * sorter is byte-identical to before. See `source-transform.ts`.
+     */
+    o(this, "perSourceSort", null);
+    /** Effect hooks folded into the vertex graph; see {@link modifiers}. */
+    o(this, "modifierList", []);
+    /** Increments when a unified gather must rebuild its source graph. */
+    o(this, "graphRevision", 0);
+    /** Version for unified work-buffer caching; source pool writes are observable. */
+    o(this, "contentRevision", 0);
+    /** Material-graph inputs kept for rebuilds when the modifier list changes. */
+    o(this, "materialInputs");
+    /** Projection focal lengths in pixels; updated every frame. */
+    o(this, "focal", b(new d.Vector2()));
+    /** Drawing-buffer size in pixels; updated every frame. */
+    o(this, "viewport", b(new d.Vector2()));
+    /** Camera position in this mesh's local space, for SH view dependence. */
+    o(this, "localCameraPosition", b(new d.Vector3()));
+    /**
+     * Frontier-cut limit for `foveationMode: 'frontier'` - the maximum
+     * `own_size / distance` a splat may have and still draw (Spark's
+     * `pixelScaleLimit`). Set each frame to `foveationTargetPx / focalPx` so the
+     * cut targets a fixed on-screen size. Unused in `'band'` mode.
+     */
+    o(this, "pixelScaleLimit", b(0));
+    /**
+     * Core projected-2D depth of field (live uniforms). Aperture `0` disables.
+     * Prefer this over the M13 `depthOfFieldPreset` modifier for camera DoF.
+     */
+    o(this, "dofFocusDistance", b(10));
+    o(this, "dofAperture", b(0));
+    /**
+     * Proxy-mesh screen-space relighting (live uniforms + map). `blend === 0`
+     * disables. Swapping the map rebuilds the material graph once.
+     */
+    o(this, "relightPlaceholder", St());
+    o(this, "relightMap", this.relightPlaceholder);
+    o(this, "relightBlend", b(0));
+    o(this, "relightBrightness", b(vt));
+    o(this, "relightBackground", b(yt));
+    o(this, "relightSoftness", b(Rt));
+    /**
+     * Live screen-radius band bounds (px), seeded from
+     * {@link SplatMeshOptions.minSplatScreenRadius} / `maxSplatScreenRadius` and
+     * moved by {@link setScreenRadiusBand} - so a foveated mesh can widen the band
+     * as its LOD cut refines rather than culling the detail the refinement bought.
+     */
+    o(this, "screenBandMin", b(0));
+    o(this, "screenBandMax", b(0));
+    /** The pick pass and everything it allocates; see `splat-mesh-picking.ts`. */
+    o(this, "picker", new Nt({
+      mesh: this,
+      isDisposed: () => this.disposed,
+      getActiveCount: () => this.activeCount,
+      getViewportSize: () => this.viewport.value,
+      getPickVisible: () => this.effectiveVisibility,
+      hasSorter: () => this.sorter !== null,
+      updateWorldMatrix: () => this.updateWorldMatrix(!0, !1),
+      prepare: (e, t) => {
+        this.flushPendingUploads(t), this.refreshProjectionUniforms(e, t), this.sorter !== null && this.requestSortIfNeeded(e, t);
+      },
+      setView: (e, t, i) => this.writeViewUniforms(e, t, i),
+      applyPickGraph: (e) => Z(
+        e,
+        "pick",
+        this.graphInputs(this.materialInputs.textures, this.materialInputs.sh)
+      )
+    }));
+    /** Visibility supplied by an owning unified renderer for source-only picks. */
+    o(this, "unifiedPickVisibility", null);
+    /** Set by {@link dispose}; subclasses use it to drop late async results. */
+    o(this, "disposed", !1);
+    /** The renderer this mesh last updated with, so {@link dispose} can free
+     * storage-attribute GPU buffers that never sat in a geometry. */
+    o(this, "lastRenderer", null);
+    o(this, "currentModelView", new d.Matrix4());
+    /** Initialized to an impossible matrix so the first frame always sorts. */
+    o(this, "lastSortedModelView", new d.Matrix4().makeScale(0, 0, 0));
+    o(this, "sortScheduler");
+    /** One-frame queue-headroom hint used before a staged atomic commit. */
+    o(this, "deferSortRequestOnce", !1);
+    /** Bumped by every active-list mutation; identifies a draw list. */
+    o(this, "activeListVersion", 0);
+    /** The active list the current depth order was built from. */
+    o(this, "sortedActiveListVersion", -1);
+    o(this, "sortStrategy");
+    /** Resolved only when `sortStrategy === 'radix'`; see {@link ensureRadixSorter}. */
+    o(this, "RadixSorterCtor", null);
+    o(this, "radixSorterLoad", null);
+    o(this, "performanceProfileValue");
+    /** Gaussian cutoff radius in σ; baked into the material graph. */
+    o(this, "maxStdDevValue");
+    /** Screen-space minimum splat radius in px; baked into the material graph. */
+    o(this, "minSplatSizePx");
+    /** Mip-Splatting 2D antialiasing filter; baked into the material graph. */
+    o(this, "antialias");
+    /** Format-selected low-pass and opacity-compensation policy. */
+    o(this, "projectedFilterProfile");
+    /** Emit sRGB colors for gamma-space compositing; baked into the material graph. */
+    o(this, "srgbOutput");
+    /** Screen-radius cull threshold in px (0 = off); baked into the material graph. */
+    o(this, "maxSplatScreenRadius");
+    o(this, "minSplatScreenRadius");
+    /** `.rad` foveation cut selector; baked into the material graph. */
+    o(this, "foveationMode");
+    /** Finest on-screen node size (px) the frontier cut may request. */
+    o(this, "foveationTargetPx");
+    /** Target upper bound on the frontier cut's drawn-splat count. */
+    o(this, "foveationDrawBudget");
+    /** Rendered major/minor axis-ratio cap (0 = off); baked into the material graph. */
+    o(this, "maxSplatAspect");
+    /** Spark LOD alpha encoding + merged-node rendering; baked into the material. */
+    o(this, "lodAlpha");
+    /** Live frontier limit in px; self-adjusts between `foveationTargetPx` (finest)
+     * and coarser to hold `foveationDrawBudget`. Feeds `pixelScaleLimit` each frame. */
+    o(this, "foveationLimitPx");
+    /** Throttle timestamp for the adaptive-limit estimate (ms, `performance.now`). */
+    o(this, "lastFoveationAdaptAt", -1 / 0);
+    /** Y-up normalization policy; drives the static self-orientation below. */
+    o(this, "orientation");
+    /** Set once the pool has been checked against the device texture limit. */
+    o(this, "textureLimitChecked", !1);
+    if (this.pool = m, this.ownsPool = w, m.register(this), this.sortScheduler = new At(i, s), this.sortStrategy = t.sortStrategy ?? "counting", this.sortStrategy === "radix" && this.ensureRadixSorter(), this.performanceProfileValue = Y(t.performanceProfile), this.maxStdDevValue = r, this.minSplatSizePx = n, this.antialias = t.antialias ?? (a ? e.antialias ?? !1 : !1), this.projectedFilterProfile = t.projectedFilterProfile ?? "default", this.srgbOutput = t.srgbOutput ?? !1, this.maxSplatScreenRadius = H(t.maxSplatScreenRadius), this.minSplatScreenRadius = H(t.minSplatScreenRadius), this.screenBandMin.value = this.minSplatScreenRadius, this.screenBandMax.value = this.maxSplatScreenRadius, this.foveationMode = mt(t.foveationMode), this.foveationTargetPx = ee(t.foveationTargetPx), this.foveationDrawBudget = se(t.foveationDrawBudget), this.foveationLimitPx = this.foveationTargetPx, this.maxSplatAspect = H(t.maxSplatAspect), this.lodAlpha = t.lodAlpha ?? !1, this.orientation = t.orientation ?? "y-up", this.splatIndexAttribute = E, this.sourceIndexAttribute = new d.StorageBufferAttribute(new Uint32Array(S), 1), this.dataTextures = m.coreTextures, this.isStatic = a, this.shEnabled = U !== null, this.shRange = { min: K(), max: K() }, this.frustumCulled = !1, U && (this.dataTextures = [...this.dataTextures, U]), I.length > 0 && (this.dataTextures = [...this.dataTextures, ...I]), this.materialInputs = {
+      textures: { centersTexture: A, colorsTexture: R, covarianceATexture: y, covarianceBTexture: M },
+      sh: a && e.sh && U ? { mode: "palette", bands: e.sh.bands, paletteTexture: U } : l !== 0 ? {
+        mode: "packed",
+        bands: l,
+        textures: I,
+        range: this.shRange
+      } : null
+    }, this.buildMaterial(this.materialInputs.textures, this.materialInputs.sh), a) {
+      this.staticRange = this.appendRange(e), this.pendingUploadRows = [], this.poolFloatTextures === "float16" && this.syncHalfFloatPoolImages();
+      const C = this.orientation === "y-up" ? Vt(e.format) : null;
+      C && (this.matrix.copy(C), this.matrix.decompose(this.position, this.quaternion, this.scale), this.matrixWorldNeedsUpdate = !0);
+    }
+  }
+  /**
+   * Pool index → this mesh's packed active-list slot. Lives on the pool: it is
+   * keyed by pool index, so a per-mesh copy would span the whole pool and
+   * several meshes sharing one would each pay for all of it. A row has one
+   * owner at a time, so the single array is unambiguous.
+   */
+  get activeSlotByPoolIndex() {
+    return this.pool.activeSlotByPoolIndex;
+  }
+  /** Rows in the pool backing this mesh. */
+  get poolRows() {
+    return this.pool.rows;
+  }
+  get centersTexture() {
+    return this.pool.centersTexture;
+  }
+  get backing() {
+    return this.pool.backing;
+  }
+  get freeRowSpans() {
+    return this.pool.freeRowSpans;
+  }
+  set freeRowSpans(e) {
+    this.pool.freeRowSpans = e;
+  }
+  get poolFloatTextures() {
+    return this.pool.floatTextures;
+  }
+  /** Bands of per-splat (non-palette) SH this pool stores; 0 when disabled. */
+  get packedShBands() {
+    return this.pool.packedShBands;
+  }
+  get shPackedTextures() {
+    return this.pool.shPackedTextures;
+  }
+  /**
+   * Higher-order SH bands this mesh actually renders (0 when it has none),
+   * whatever the source: a static mesh's palette shN, or per-splat SH in a
+   * dynamic pool. Reflects what was resolved at construction, not what was
+   * asked for - useful for a debug readout.
+   */
+  get shBands() {
+    var e;
+    return ((e = this.materialInputs.sh) == null ? void 0 : e.bands) ?? 0;
+  }
+  /**
+   * The contribution-culling profile currently in effect (resolved at
+   * construction, or the last {@link setPerformanceProfile} value).
+   */
+  get performanceProfile() {
+    return this.performanceProfileValue;
+  }
+  /**
+   * Changes contribution culling without changing scene data or persisted
+   * settings.
+   *
+   * Mutator convention: state that is plain data is a property (get/set pair);
+   * a `setX` method exists where the write has behavior - this one rebuilds the
+   * material graph, {@link StreamedSplatMesh.setBudget} returns its clamp.
+   * Every mutator has a matching readable property.
+   */
+  setPerformanceProfile(e) {
+    e !== this.performanceProfileValue && (this.performanceProfileValue = e, this.buildMaterial(this.materialInputs.textures, this.materialInputs.sh));
+  }
+  /**
+   * Gaussian cutoff radius currently in effect, in standard deviations.
+   * Resolved at construction, or the last {@link setMaxStdDev} value.
+   */
+  get maxStdDev() {
+    return this.maxStdDevValue;
+  }
+  /**
+   * Changes the Gaussian cutoff without changing scene data.
+   *
+   * Lowering it shrinks every quad and is the main fill-rate lever in a busy
+   * view; raising it restores the faint outer tail. Rebuilds the material
+   * graph, same convention as {@link setPerformanceProfile}.
+   */
+  setMaxStdDev(e) {
+    const t = ct(e);
+    t === void 0 || t === this.maxStdDevValue || (this.maxStdDevValue = t, this.cachedUnifiedView = null, this.buildMaterial(this.materialInputs.textures, this.materialInputs.sh));
+  }
+  /**
+   * Copies a decoded scene (or chunk) into the pool and activates it.
+   * Ranges are row-aligned in the pool textures, so each allocation may
+   * round up to the next multiple of the texture width internally.
+   *
+   * @returns A handle to pass to {@link removeRange}.
+   * @throws {Error} when the remaining pool capacity cannot fit the range.
+   */
+  appendRange(e) {
+    return this.appendRangeWithState(e, !0);
+  }
+  /** Appends uploaded data without exposing it to draw/sort until activated. */
+  appendInactiveRange(e) {
+    return this.appendRangeWithState(e, !1);
+  }
+  /** Reserves an inactive pool range whose data can be filled over multiple frames. */
+  reserveInactiveRange(e) {
+    if (!Number.isInteger(e) || e < 0)
+      throw new RangeError("SplatMesh.reserveInactiveRange: count must be a non-negative integer.");
+    if (e === 0) {
+      const a = Object.freeze({ count: 0 });
+      return this.ranges.set(a, { startRow: 0, rowCount: 0, start: 0, count: 0, active: !1 }), a;
+    }
+    const t = v.DATA_TEXTURE_WIDTH, i = Math.ceil(e / t), s = Q(this.freeRowSpans, i, this.poolRows), r = s * t, n = Object.freeze({ count: e });
+    this.ranges.set(n, { startRow: s, rowCount: i, start: r, count: e, active: !1 });
+    for (const a of this.channels.values())
+      a.backing.fill(a.fill, r, r + i * t), a.pendingRows.push({ start: s, count: i });
+    return n;
+  }
+  /** Writes one contiguous segment of a reserved inactive range. */
+  writeInactiveRange(e, t, i) {
+    const s = this.ranges.get(e);
+    if (!s) throw new Error("SplatMesh.writeInactiveRange: unknown range handle.");
+    if (s.active) throw new Error("SplatMesh.writeInactiveRange: range is already active.");
+    if (!Number.isInteger(i) || i < 0 || i + t.count > s.count)
+      throw new RangeError("SplatMesh.writeInactiveRange: write exceeds the reserved range.");
+    if (t.count === 0) return;
+    this.warnOnIgnoredSh(t, "writeInactiveRange");
+    const r = s.start + i;
+    this.writeSplatRows(r, t);
+    const n = v.DATA_TEXTURE_WIDTH, a = Math.floor(r / n), c = Math.floor((r + t.count - 1) / n);
+    this.markRowsWritten(a, c - a + 1), F.setFromArray(t.positions), this.localBounds.union(F), this.boundsDirty = !0;
+  }
+  /**
+   * Overwrites splats at `offset` within a range **in place** - unlike
+   * {@link writeInactiveRange} this allows an *active* range, so the frontier
+   * page table can page individual slots of its always-active slab. Queues the
+   * touched rows for upload; the caller must {@link invalidateSort} once per
+   * batch since splat depths changed.
+   */
+  overwriteRangeData(e, t, i) {
+    const s = this.ranges.get(e);
+    if (!s) throw new Error("SplatMesh.overwriteRangeData: unknown range handle.");
+    if (!Number.isInteger(i) || i < 0 || i + t.count > s.count)
+      throw new RangeError("SplatMesh.overwriteRangeData: write exceeds the range.");
+    if (t.count === 0) return;
+    this.warnOnIgnoredSh(t, "overwriteRangeData");
+    const r = s.start + i;
+    this.writeSplatRows(r, t);
+    const n = v.DATA_TEXTURE_WIDTH, a = Math.floor(r / n), c = Math.floor((r + t.count - 1) / n);
+    this.markRowsWritten(a, c - a + 1), F.setFromArray(t.positions), this.localBounds.union(F), this.boundsDirty = !0, this.contentRevision++;
+  }
+  /**
+   * Zeros splats `[offset, offset + count)` of a range so they draw nothing
+   * (zero covariance → degenerate quad, zero color). Used to free frontier slab
+   * slots that leave the frontier. Queues the rows for upload.
+   */
+  degenerateRange(e, t, i) {
+    const s = this.ranges.get(e);
+    if (!s) throw new Error("SplatMesh.degenerateRange: unknown range handle.");
+    if (i <= 0) return;
+    if (!Number.isInteger(t) || t < 0 || t + i > s.count)
+      throw new RangeError("SplatMesh.degenerateRange: range out of bounds.");
+    const r = s.start + t, { centers: n, colors: a, covarianceA: c, covarianceB: h } = this.backing;
+    n.fill(0, r * 4, (r + i) * 4), a.fill(0, r * 4, (r + i) * 4), c.fill(0, r * 4, (r + i) * 4), h.fill(0, r * 4, (r + i) * 4);
+    const l = v.DATA_TEXTURE_WIDTH, f = Math.floor(r / l), x = Math.floor((r + i - 1) / l);
+    this.markRowsWritten(f, x - f + 1), this.contentRevision++;
+  }
+  /**
+   * Copies one chunk's splats into the pool's backing arrays at `destination`.
+   * Shared by the append and staged-write paths, which differ only in where
+   * the rows come from and when they are activated.
+   */
+  writeSplatRows(e, t) {
+    const { centers: i, colors: s, covarianceA: r, covarianceB: n } = this.backing;
+    s.set(t.colors, e * 4);
+    const a = t.count, c = t.positions, h = t.covariances, l = this.shEnabled && t.sh ? t.sh.labels : null, f = t.frontierParent ?? null;
+    for (let x = 0; x < a; x++) {
+      const p = (e + x) * 4, w = x * 3, m = x * 6;
+      i[p + 0] = c[w + 0], i[p + 1] = c[w + 1], i[p + 2] = c[w + 2], r[p + 0] = h[m + 0], r[p + 1] = h[m + 1], r[p + 2] = h[m + 2], r[p + 3] = h[m + 3], n[p + 0] = h[m + 4], n[p + 1] = h[m + 5], n[p + 2] = l ? l[x] : 0, n[p + 3] = f ? f[x] : 0;
+    }
+    this.writePackedSh(e, t);
+  }
+  /**
+   * Scatters a chunk's packed SH words into the per-group pool textures.
+   *
+   * A chunk without SH still writes: pool rows are reused, so leaving the
+   * previous occupant's words behind would give a DC-only chunk somebody
+   * else's view-dependent color. Zero is not neutral (the range is signed and
+   * rarely symmetric), so the code for "0.0" in this scene's range is.
+   */
+  writePackedSh(e, t) {
+    if (this.packedShBands === 0) return;
+    const i = this.backing.shPacked, s = J(this.packedShBands), r = t.shPacked;
+    if (r && r.bands === this.packedShBands) {
+      this.applyShRange(r);
+      const a = this.currentShRange(), c = a !== null && !Et(r.range, a);
+      for (let h = 0; h < t.count; h++)
+        for (let l = 0; l < s; l++) {
+          const f = r.packed[h * s + l];
+          i[l >> 2][(e + h) * 4 + (l & 3)] = c ? Wt(f, r.range, a) : f;
+        }
+      return;
+    }
+    this.shRangeSet || (this.wrotePreLockNeutralSh = !0);
+    const n = this.neutralShWord();
+    for (let a = 0; a < t.count; a++)
+      for (let c = 0; c < s; c++)
+        i[c >> 2][(e + a) * 4 + (c & 3)] = n;
+  }
+  /**
+   * Adopts the first packed-SH chunk's dequantization range as the scene's one
+   * pool uniform. LCC/`.rad` chunks already share one range; a streamed SOG
+   * chunk measures its own extent, so later chunks are requantized into this
+   * one at write time ({@link writePackedSh}) rather than ignored.
+   */
+  applyShRange(e) {
+    if (!this.shRangeSet && (this.shRange.min.value.set(e.range.min[0], e.range.min[1], e.range.min[2]), this.shRange.max.value.set(e.range.max[0], e.range.max[1], e.range.max[2]), this.shRangeSet = !0, this.wrotePreLockNeutralSh)) {
+      const t = this.neutralShWord();
+      for (const i of this.backing.shPacked) i.fill(t);
+      this.markRowsWritten(0, this.poolRows), this.wrotePreLockNeutralSh = !1;
+    }
+  }
+  /** The scene's locked packed-SH range as a plain tuple, or null if unset. */
+  currentShRange() {
+    if (!this.shRangeSet) return null;
+    const { min: e, max: t } = this.shRange;
+    return {
+      min: [e.value.x, e.value.y, e.value.z],
+      max: [t.value.x, t.value.y, t.value.z]
+    };
+  }
+  /** The packed word decoding to 0 in every channel under the scene's range. */
+  neutralShWord() {
+    const e = this.currentShRange();
+    return e ? Lt(e) : 0;
+  }
+  /** Warns once per call site when a source's SH cannot be stored. */
+  warnOnIgnoredSh(e, t) {
+    e.sh && !this.isStatic && O(
+      `SplatMesh.${t}: palette shN data on appended ranges is ignored in dynamic-capacity mode (per-file palettes cannot be merged into a shared pool).`
+    ), e.shPacked && this.packedShBands === 0 && O(
+      `SplatMesh.${t}: per-splat SH was supplied but the pool has none allocated ` + (this.isStatic ? "(the static source had no `shPacked` at construction)." : "(construct the mesh with `shBands` to store it).")
+    );
+  }
+  /** Atomically includes or excludes a resident range on the next active-list rebuild. */
+  setRangeActive(e, t) {
+    const i = this.ranges.get(e);
+    if (!i) throw new Error("SplatMesh.setRangeActive: unknown range handle.");
+    i.active !== t && (i.active = t, t ? this.activateRecord(i) : this.deactivateRecord(i), this.contentRevision++);
+  }
+  /**
+   * Activates only the first `prefix` splats of a range (see
+   * {@link RangeRecord.activePrefix}). The page-table slab keeps its used slots
+   * densely packed at the front, so this bounds per-frame sorting and vertex
+   * work to the *drawn* frontier instead of the whole pool-sized slab. Write
+   * APIs (`overwriteRangeData` / `degenerateRange`) still address the full range.
+   */
+  setRangeActivePrefix(e, t) {
+    const i = this.ranges.get(e);
+    if (!i) throw new Error("SplatMesh.setRangeActivePrefix: unknown range handle.");
+    const s = Math.max(0, Math.min(i.count, Math.floor(t))), r = i.active ? i.activePrefix ?? i.count : 0;
+    s !== r && (i.active && (this.deactivateRecord(i), i.active = !1), i.activePrefix = s, s > 0 && (i.active = !0, this.activateRecord(i)), this.contentRevision++);
+  }
+  /**
+   * Replaces the drawn pool indices for an immutable static hierarchy.
+   *
+   * This is intentionally narrower than the range API: subclasses may select
+   * an arbitrary hierarchy frontier, but the referenced pool rows must remain
+   * resident for the lifetime of the mesh.
+   */
+  replaceActiveIndices(e) {
+    const t = this.sourceIndexAttribute.array;
+    if (e.length > t.length)
+      throw new RangeError("SplatMesh.replaceActiveIndices: frontier exceeds pool capacity.");
+    this.activeSlotByPoolIndex.fill(4294967295);
+    for (let s = 0; s < e.length; s++) {
+      const r = e[s];
+      if (r >= t.length)
+        throw new RangeError(
+          "SplatMesh.replaceActiveIndices: frontier contains an invalid pool index."
+        );
+      if (this.activeSlotByPoolIndex[r] !== 4294967295)
+        throw new Error(
+          "SplatMesh.replaceActiveIndices: frontier contains duplicate pool indices."
+        );
+      t[s] = r, this.activeSlotByPoolIndex[r] = s;
+    }
+    const i = this.activeCount;
+    this.activeCount = e.length, this.commitActiveListMutation(0, Math.max(i, this.activeCount)), this.queryEpoch++, this.contentRevision++;
+  }
+  /** Fast identity-frontier variant that avoids allocating a large index array. */
+  replaceActivePrefix(e) {
+    const t = this.sourceIndexAttribute.array, i = Math.max(0, Math.min(t.length, Math.floor(e)));
+    this.activeSlotByPoolIndex.fill(4294967295);
+    for (let r = 0; r < i; r++)
+      t[r] = r, this.activeSlotByPoolIndex[r] = r;
+    const s = this.activeCount;
+    this.activeCount = i, this.commitActiveListMutation(0, Math.max(s, i)), this.queryEpoch++, this.contentRevision++;
+  }
+  /** Replaces a static mesh's resident cut without increasing its fixed pool allocation. */
+  replaceStaticData(e) {
+    if (!this.isStatic || !this.staticRange)
+      throw new Error("SplatMesh.replaceStaticData: mesh was not constructed from static data.");
+    if (e.count > this.capacity)
+      throw new RangeError("SplatMesh.replaceStaticData: cut exceeds pool capacity.");
+    this.overwriteRangeData(this.staticRange, e, 0), this.setRangeActivePrefix(this.staticRange, e.count), this.invalidateSort();
+  }
+  appendRangeWithState(e, t) {
+    if (e.count === 0) {
+      const h = Object.freeze({ count: 0 });
+      return this.ranges.set(h, { startRow: 0, rowCount: 0, start: 0, count: 0, active: t }), h;
+    }
+    const i = v.DATA_TEXTURE_WIDTH, s = Math.ceil(e.count / i), r = Q(this.freeRowSpans, s, this.poolRows), n = r * i;
+    this.warnOnIgnoredSh(e, "appendRange"), this.writeSplatRows(n, e);
+    const a = Object.freeze({ count: e.count }), c = { startRow: r, rowCount: s, start: n, count: e.count, active: t };
+    this.ranges.set(a, c), this.markRowsWritten(r, s);
+    for (const h of this.channels.values())
+      h.backing.fill(h.fill, n, n + s * i), h.pendingRows.push({ start: r, count: s });
+    return F.setFromArray(e.positions), this.localBounds.union(F), this.boundsDirty = !0, t && this.activateRecord(c), this.contentRevision++, a;
+  }
+  /**
+   * Deactivates a previously appended range and frees its pool rows for
+   * reuse. The bounding sphere used for depth quantization stays a
+   * conservative superset until new ranges grow it again.
+   */
+  removeRange(e) {
+    const t = this.ranges.get(e);
+    if (!t) throw new Error("SplatMesh.removeRange: unknown range handle.");
+    t.active && this.deactivateRecord(t), this.ranges.delete(e), t.rowCount > 0 && (this.freeRowSpans = Mt(this.freeRowSpans, t.startRow, t.rowCount)), this.contentRevision++;
+  }
+  /** Maximum number of splats the pool can hold (row-aligned internally). */
+  get capacity() {
+    return this.poolRows * v.DATA_TEXTURE_WIDTH;
+  }
+  /** Number of splats currently active (drawn and depth-sorted). */
+  get activeSplatCount() {
+    return this.activeCount;
+  }
+  /**
+   * Returns this mesh's current pool state for an internal unified gather.
+   * Call {@link update} first for streamed sources so the active list reflects
+   * the current LOD cut. Consumers must treat the returned GPU resources as
+   * read-only; range lifecycle remains owned by this mesh.
+   */
+  getUnifiedSourceView() {
+    this.updateWorldMatrix(!0, !1), this.refreshSortBounds();
+    const e = this.cachedUnifiedView;
+    return e !== null && e.contentRevision === this.contentRevision && e.graphRevision === this.graphRevision && e.activeCount === this.activeCount && e.sh === this.materialInputs.sh && e.modifiers === this.modifierList && e.hasSourcePlacement === (this.perSourceSort !== null) && e.centersTexture === this.centersTexture && e.colorsTexture === this.materialInputs.textures.colorsTexture && this.cachedUnifiedViewMatrixWorld.equals(this.matrixWorld) && this.cachedUnifiedViewLocalBounds.equals(this.boundingSphereLocal) ? e : (this.cachedUnifiedViewMatrixWorld.copy(this.matrixWorld), this.cachedUnifiedViewLocalBounds.copy(this.boundingSphereLocal), this.cachedUnifiedViewWorldBounds.copy(this.boundingSphereLocal).applyMatrix4(this.matrixWorld), this.cachedUnifiedView = {
+      capacity: this.capacity,
+      sourceIndex: this.sourceIndexAttribute,
+      activeCount: this.activeCount,
+      centersTexture: this.centersTexture,
+      colorsTexture: this.materialInputs.textures.colorsTexture,
+      covarianceATexture: this.materialInputs.textures.covarianceATexture,
+      covarianceBTexture: this.materialInputs.textures.covarianceBTexture,
+      dataTextureWidth: v.DATA_TEXTURE_WIDTH,
+      matrixWorld: this.matrixWorld,
+      worldBounds: this.cachedUnifiedViewWorldBounds,
+      sh: this.materialInputs.sh,
+      modifiers: this.modifierList,
+      hasSourcePlacement: this.perSourceSort !== null,
+      channels: this.channels,
+      localCameraPosition: this.localCameraPosition,
+      graphRevision: this.graphRevision,
+      srgbOutput: this.srgbOutput,
+      maxStdDev: this.maxStdDev,
+      minSplatSizePx: this.minSplatSizePx,
+      antialias: this.antialias,
+      projectedFilterProfile: this.projectedFilterProfile,
+      // Fixed at construction, so it needs no cache-invalidation key.
+      lodAlpha: this.lodAlpha,
+      contentRevision: this.contentRevision
+    }, this.cachedUnifiedView);
+  }
+  /**
+   * Marks this mesh as a source drawn by {@link UnifiedSplatMesh}.
+   * The source stays invisible to the regular scene draw, while its own picker
+   * mirrors this resolved visibility so existing per-source hit testing works.
+   * Internal consumers should clear the state with `null` before disposing.
+   */
+  setUnifiedPickVisibility(e) {
+    this.unifiedPickVisibility = e;
+  }
+  /**
+   * The visibility that actually decides whether this mesh's splats reach the
+   * screen: the owning {@link UnifiedSplatMesh}'s per-source visibility
+   * while one owns the draw, else `Object3D.visible`. Consumers that gate on
+   * "is this mesh showing" - the picker, `CameraBudgetGovernor` - must read
+   * this rather than `visible`, which a unified renderer forces to `false` on
+   * every source it owns purely to keep the regular scene draw from
+   * double-drawing them.
+   */
+  get effectiveVisibility() {
+    return this.unifiedPickVisibility ?? this.visible;
+  }
+  /**
+   * Pool splats still allocatable, in whole rows. Because allocation is
+   * row-aligned, an append of n splats fits when
+   * `ceil(n / rowWidth) · rowWidth ≤ freeSplatCapacity` *and* a contiguous
+   * span exists; callers use this for conservative pre-checks before
+   * falling back to {@link compact}.
+   */
+  get freeSplatCapacity() {
+    let e = 0;
+    for (const t of this.freeRowSpans) e += t.count;
+    return e * v.DATA_TEXTURE_WIDTH;
+  }
+  /**
+   * Declares a named per-splat data channel - one extra value per pool slot,
+   * in its own pool-aligned data texture. Channels are opt-in: nothing is
+   * allocated until you call this. Read a channel from a modifier with
+   * `ctx.channel(name)` and write values per range with {@link writeChannel}.
+   *
+   * Because a splat keeps its pool row for its whole residency, a channel
+   * value follows the splat across depth re-sorts and pool {@link compact}ion
+   * - the persistent per-splat label the SDF/selection effects build on. Call
+   * this **before** assigning a modifier that reads the channel; a modifier
+   * that reads an undeclared channel is a material-build error.
+   *
+   * @throws {Error} if a channel of this name already exists.
+   */
+  defineChannel(e, t = {}) {
+    if (this.channels.has(e))
+      throw new Error(`SplatMesh.defineChannel: channel "${e}" already defined.`);
+    const i = t.type ?? "float", s = v.DATA_TEXTURE_WIDTH, r = s * this.poolRows, n = i === "byte" ? new Uint8Array(r) : new Float32Array(r), a = t.fill ?? 0;
+    a && n.fill(a);
+    const c = i === "byte" ? d.UnsignedByteType : d.FloatType, h = new d.DataTexture(
+      n,
+      s,
+      this.poolRows,
+      d.RedFormat,
+      c
+    );
+    h.needsUpdate = !0, this.channels.set(e, { type: i, fill: a, backing: n, texture: h, textureType: c, pendingRows: [] });
+  }
+  /**
+   * Writes channel values for a resident range, at `[offset, offset + data.length)`
+   * splats within it (default `offset` 0). Values ride the same staging-upload
+   * path as pool data, flushed on the next {@link update}. `byte` channels take
+   * raw `0..255`; `float` channels take the value verbatim.
+   *
+   * @throws {Error} for an unknown channel or range, or a write past the range.
+   */
+  writeChannel(e, t, i, s = 0) {
+    const r = this.channels.get(t);
+    if (!r) throw new Error(`SplatMesh.writeChannel: channel "${t}" is not defined.`);
+    const n = this.ranges.get(e);
+    if (!n) throw new Error("SplatMesh.writeChannel: unknown range handle.");
+    if (s < 0 || s + i.length > n.count)
+      throw new Error(
+        `SplatMesh.writeChannel: write of ${i.length} at offset ${s} exceeds range count ${n.count}.`
+      );
+    if (i.length === 0) return;
+    const a = v.DATA_TEXTURE_WIDTH, c = n.start + s;
+    r.backing.set(i, c);
+    const h = Math.floor(c / a), l = Math.floor((c + i.length - 1) / a);
+    r.pendingRows.push({ start: h, count: l - h + 1 }), this.contentRevision++;
+  }
+  /**
+   * Effect hooks, folded into the vertex stage in array order - each
+   * modifier sees the running result of the ones before it. Assigning a
+   * changed list rebuilds the material (a pipeline recompile); animating a
+   * modifier's own uniforms or storage buffers never does. With an empty
+   * list the material is exactly the unhooked renderer.
+   * See `docs/guide/effects-and-modifiers.md`.
+   */
+  get modifiers() {
+    return this.modifierList;
+  }
+  set modifiers(e) {
+    if (e.length === this.modifierList.length && e.every((s, r) => s === this.modifierList[r])) return;
+    const i = this.modifierList;
+    this.modifierList = [...e];
+    try {
+      this.rebuildGraph();
+    } catch (s) {
+      throw this.modifierList = i, this.buildMaterial(this.materialInputs.textures, this.materialInputs.sh), s;
+    }
+  }
+  /**
+   * Recompiles the material graph from the mesh's current inputs and publishes
+   * the rebuild (`needsUpdate`, `graphRevision`, picker invalidation).
+   *
+   * A seam rather than inline code because a subclass can change a *build
+   * input* without changing the modifier list - `MergedSplatMesh` installs its
+   * per-source placement in the constructor, after the base class has already
+   * built a placement-free graph. Note `defineChannel` deliberately does *not*
+   * rebuild; only structural graph changes come through here.
+   *
+   * @internal
+   */
+  rebuildGraph() {
+    this.buildMaterial(this.materialInputs.textures, this.materialInputs.sh), this.material.needsUpdate = !0, this.graphRevision++, this.picker.markNeedsUpdate();
+  }
+  /**
+   * Core projected-2D depth of field. Adds an isotropic screen-space CoC disc
+   * after EWA projection (not the stylized M13 scale modifier). Live uniforms
+   * - no material rebuild. Pass `aperture: 0` to disable.
+   */
+  setDepthOfField(e) {
+    const t = It(e, this.getDepthOfField());
+    this.dofFocusDistance.value = t.focusDistance, this.dofAperture.value = t.aperture;
+  }
+  /**
+   * PlayCanvas-style proxy-mesh relighting. Multiplies baked splat color in the
+   * **display** fragment by a screen-space sample of `map` (RGB = lit proxy,
+   * A = coverage). Pass `null` to disable (`blend → 0`, placeholder map).
+   *
+   * Blend / brightness / background are live uniforms (no rebuild). Changing
+   * the map texture identity rebuilds the material once. Does not affect the
+   * pick pass. Does not invalidate a unified gather cache.
+   */
+  setRelighting(e) {
+    if (e === null) {
+      this.relightBlend.value = 0, this.relightMap !== this.relightPlaceholder && (this.relightMap = this.relightPlaceholder, this.rebuildGraph());
+      return;
+    }
+    const t = kt(e, this.getRelighting());
+    this.relightBlend.value = t.blend, this.relightBrightness.value = t.brightness, this.relightBackground.value = t.background, this.relightSoftness.value = t.softness, e.map !== this.relightMap && (this.relightMap = e.map, this.rebuildGraph());
+  }
+  /** Current relight numeric uniforms (`blend === 0` means off). */
+  getRelighting() {
+    return {
+      blend: this.relightBlend.value,
+      brightness: this.relightBrightness.value,
+      background: this.relightBackground.value,
+      softness: this.relightSoftness.value
+    };
+  }
+  /**
+   * Moves the screen-radius band (px) without rebuilding the material.
+   *
+   * Only meaningful on a mesh constructed *with* a band - the graph decides at
+   * build time whether to cull on radius at all, from
+   * {@link SplatMeshOptions.minSplatScreenRadius} / `maxSplatScreenRadius`.
+   *
+   * A foveated mesh uses this to keep the band aligned with its LOD cut: the
+   * band spans roughly one level, so refining the cut to spend spare budget
+   * selects smaller splats, and a band left where it was would cull precisely
+   * the detail that refinement bought.
+   */
+  setScreenRadiusBand(e, t) {
+    this.screenBandMin.value = Math.max(0, e), this.screenBandMax.value = Math.max(0, t);
+  }
+  /** Current core DoF uniforms (`aperture === 0` means off). */
+  getDepthOfField() {
+    return {
+      focusDistance: this.dofFocusDistance.value,
+      aperture: this.dofAperture.value
+    };
+  }
+  /**
+   * Packs the resident ranges toward the start of the pool, removing the
+   * gaps that add/remove churn leaves behind and restoring a single
+   * contiguous free span. Use this when {@link appendRange} throws despite
+   * enough total free rows (row-alignment fragmentation).
+   *
+   * The CPU backing arrays are authoritative, so no data is re-fetched;
+   * moved rows are re-uploaded to the GPU on the next {@link update}.
+   */
+  compact() {
+    this.pool.compact();
+  }
+  /** {@link SplatPoolTenant}: the ranges this mesh holds in the pool. */
+  poolRanges() {
+    return this.ranges.values();
+  }
+  /**
+   * {@link SplatPoolTenant}: follow one range to its new rows. The pool has
+   * already moved the splat data; this moves what the mesh keys by pool row.
+   */
+  relocatePoolRange(e, t) {
+    const i = e, s = v.DATA_TEXTURE_WIDTH;
+    for (const r of this.channels.values()) {
+      const n = i.startRow * s, a = t * s, c = i.rowCount * s;
+      r.backing.copyWithin(a, n, n + c), r.pendingRows.push({ start: t, count: i.rowCount });
+    }
+    i.startRow = t, i.start = t * s, this.markRowsWritten(t, i.rowCount);
+  }
+  /** {@link SplatPoolTenant}: rebuild everything keyed by pool index. */
+  onPoolCompacted() {
+    this.queryEpoch++, this.rebuildActiveList(), this.contentRevision++;
+  }
+  /**
+   * Per-frame update: uploads pending pool writes, refreshes the projection
+   * uniforms and requests a depth re-sort when the camera or the content
+   * has changed. Call this every frame, before `renderer.render`.
+   */
+  update(e, t, i = {}) {
+    if (this.disposed) return;
+    this.lastRenderer = t, this.assertPoolFitsDevice(t), e.updateMatrixWorld(), this.updateWorldMatrix(!0, !1), this.updateTimings.activeListMs = 0, this.updateTimings.uploadMs = 0, this.updateTimings.sortSubmitMs = 0, this.updateTimings.stagingTextureAllocations = 0, this.updateTimings.activeListUpdateRanges = 0;
+    const s = performance.now();
+    this.flushPendingUploads(t), this.updateTimings.uploadMs = performance.now() - s;
+    const r = Pt(e, t);
+    let n = e, a = e, c, h;
+    if (r ? (n = r.eye, a = r.head, c = r.width, h = r.height) : (t.getDrawingBufferSize(P), c = P.x, h = P.y), this.adaptFoveationLimit(n, h), this.writeViewUniforms(n, c, h, a), this.updateTimings.activeListUpdateRanges = this.sourceIndexAttribute.updateRanges.length, i.sort !== !1) {
+      const l = performance.now();
+      this.requestSortIfNeeded(a, t), this.updateTimings.sortSubmitMs = performance.now() - l;
+    }
+  }
+  /** Returns the render-preparation CPU timings for the current update. */
+  getUpdateTimings() {
+    return this.updateTimings;
+  }
+  /**
+   * Skips one otherwise ordinary sort request, but only while the active list
+   * is unchanged since the last sort. Streamed staging uses this immediately
+   * before a forced commit sort so the GPU queue has a frame to drain; a
+   * concurrent swap group that mutates the active list revokes the request,
+   * because the depth order must always describe the list being drawn.
+   */
+  deferNextSortRequest() {
+    this.deferSortRequestOnce = !0;
+  }
+  /**
+   * Once, on the first update (when the backend is known), fails loudly if the
+   * pool's `2048 × poolRows` data textures exceed the device's maximum texture
+   * dimension - otherwise the upload fails with a cryptic backend error and a
+   * frozen canvas. Streamed scenes stay under the limit (budget-bounded); this
+   * guards very large *static* scenes, especially on mobile (≈8192 max → about
+   * 16.7 M splats). If the limit can't be read, the check is skipped rather
+   * than risk a false rejection.
+   */
+  assertPoolFitsDevice(e) {
+    if (this.textureLimitChecked) return;
+    this.textureLimitChecked = !0;
+    const t = Ct(e);
+    if (t > 0 && this.poolRows > t) {
+      const i = v.DATA_TEXTURE_WIDTH;
+      throw new Error(
+        `SplatMesh: this scene needs a ${i}×${this.poolRows} data texture, but this device caps texture dimensions at ${t} (about ${(t * i).toLocaleString("en-US")} splats). Stream it with StreamedSplatMesh, or reduce the splat count.`
+      );
+    }
+  }
+  /** Bounding box of the appended splats, in this mesh's local space. */
+  computeSplatBounds() {
+    return this.localBounds.clone();
+  }
+  /**
+   * Asynchronously picks the frontmost visible splat under an NDC coordinate.
+   *
+   * Renders a one-pixel GPU depth pass (shared projection/Gaussian math with
+   * the display material), reads the encoded view depth, and reconstructs a
+   * world-space point on the splat's rendered center plane. Concurrent calls
+   * on this mesh are serialized. Returns `null` for misses, empty meshes,
+   * out-of-canvas coordinates, or after {@link dispose}.
+   *
+   * Does not return a persistent splat id - LOD streaming and pool reuse make
+   * identity unstable across frames.
+   */
+  pick(e, t, i, s) {
+    return this.picker.pick(e, t, i, s);
+  }
+  /**
+   * The resident splat center nearest a world point, within `radius` (world
+   * units), or `null` if none. A synchronous CPU query over the pool's decoded
+   * centers - no GPU round-trip - backed by a uniform grid rebuilt only when
+   * the resident set changes (M9). The primitive behind measurement markers and
+   * proximity tests.
+   *
+   * **Resident-only:** a {@link StreamedSplatMesh} searches only the splats
+   * currently in the pool (the LOD the camera has resolved), so the answer is
+   * the nearest *loaded* splat - coarser far from the camera, absent where no
+   * chunk has streamed in. A static mesh searches its whole scene.
+   *
+   * World-correct under any rotation + per-axis (including non-uniform) scale:
+   * candidates are gathered in local space with a conservative radius
+   * (`radius / min axis scale`) and then ranked by **world** distance, so the
+   * nearest-in-world splat wins even when the axes stretch differently. Shear
+   * in an ancestor transform is not supported. Splats displaced by GPU
+   * modifiers are queried at their undisplaced CPU positions.
+   */
+  queryNearest(e, t) {
+    if (this.activeCount === 0 || !(t >= 0)) return null;
+    this.updateWorldMatrix(!0, !1), T.copy(e), this.worldToLocal(T);
+    const i = this.ensureQueryGrid(), s = t / this.queryWorldMinScale(), r = t * t;
+    let n = -1, a = 1 / 0;
+    return i.forEachWithin(T.x, T.y, T.z, s, (h) => {
+      this.splatWorldPosition(h, k);
+      const l = k.distanceToSquared(e);
+      l <= r && l < a && (a = l, n = h);
+    }), n < 0 ? null : { point: this.splatWorldPosition(n, new d.Vector3()), distance: Math.sqrt(a) };
+  }
+  /**
+   * Returns the first resident splat center inside a world-space ray cone.
+   * This is a synchronous CPU query, intended for interactions that cannot
+   * wait for (or rely on) a GPU readback. `radiusAtUnitDistance` is the cone's
+   * world-space radius one unit from the origin; `minimumRadius` keeps nearby
+   * point-like splats practical to target.
+   *
+   * Like {@link queryNearest}, this searches resident, undisplaced CPU centers.
+   */
+  queryRay(e, t = 0.025, i = 0.05) {
+    if (this.activeCount === 0 || !(t >= 0) || !(i >= 0) || e.direction.lengthSq() === 0)
+      return null;
+    this.updateWorldMatrix(!0, !1);
+    const s = this.sourceIndexAttribute.array.subarray(0, this.activeCount);
+    let r = -1, n = 1 / 0;
+    for (const a of s) {
+      this.splatWorldPosition(a, k), T.subVectors(k, e.origin);
+      const c = T.dot(e.direction);
+      if (c < 0 || c >= n) continue;
+      T.addScaledVector(e.direction, -c);
+      const h = Math.max(i, c * t);
+      T.lengthSq() <= h * h && (r = a, n = c);
+    }
+    return r < 0 ? null : {
+      point: this.splatWorldPosition(r, new d.Vector3()),
+      distance: n
+    };
+  }
+  /**
+   * The supporting surface beneath a world point: the highest resident splat
+   * that lies no more than `maxDrop` below it (world −Y) and within `radius`
+   * horizontally, or `null` if none. A downward probe over splat centers - the
+   * primitive behind floor-following and teleport validation - without a GPU
+   * pick or a collision mesh (M9), so it works for every format, not only the
+   * `.lcc2` captures that ship collision geometry.
+   *
+   * `radius` (default `maxDrop / 2`) is the horizontal tolerance: splats are
+   * points, so an exact vertical hit is unlikely and a small disc is searched.
+   * Resident-only semantics and the world-correctness contract (rotation +
+   * per-axis scale supported, shear not) are the same as {@link queryNearest};
+   * every candidate is judged in world space, where the −Y probe direction is
+   * defined, so the vertical test never assumes local axis alignment.
+   */
+  queryHeight(e, t, i = t / 2) {
+    if (this.activeCount === 0 || !(t >= 0) || !(i >= 0)) return null;
+    this.updateWorldMatrix(!0, !1), T.copy(e), this.worldToLocal(T);
+    const s = this.ensureQueryGrid(), r = (t + i) / this.queryWorldMinScale(), n = i * i;
+    let a = -1 / 0, c = -1;
+    if (s.forEachWithin(T.x, T.y, T.z, r, (l) => {
+      this.splatWorldPosition(l, k);
+      const f = e.y - k.y;
+      if (f < 0 || f > t) return;
+      const x = k.x - e.x, p = k.z - e.z;
+      x * x + p * p > n || k.y > a && (a = k.y, c = l);
+    }), c < 0) return null;
+    const h = this.splatWorldPosition(c, new d.Vector3());
+    return { point: h, drop: e.y - h.y };
+  }
+  /**
+   * Renders this mesh from a second camera - into `target`, or the canvas when
+   * omitted - with depth order **and** projection correct for *that* camera
+   * (M10). The primitive behind mirrors, portals, split panes, and thumbnails.
+   *
+   * Depth order is view-dependent, but a mesh keeps one sorted order buffer:
+   * `update()` sorts it for the single camera it is given, so a second view
+   * drawn with that order shows transparency/pop errors. `renderView` re-sorts
+   * for `camera` into the shared buffer, sets the view-dependent uniforms
+   * (viewport from `target`), draws, and marks the primary order stale so the
+   * next `update()` re-sorts for the main camera. GPU submissions execute in
+   * order, so each view's draw reads the order and uniforms it just wrote.
+   *
+   * Call once per extra view per frame, before or after the primary
+   * `update()` + render - both are correct. On the WebGL2 fallback the sorter
+   * is an asynchronous worker owned by the primary view, so `renderView` does
+   * not sort at all there: the secondary view draws with the primary view's
+   * order (projection is still per-camera correct) - a documented single-view
+   * ordering limitation; WebGPU gets exact per-view order.
+   *
+   * @param target - Destination render target, or `null`/omitted for the canvas.
+   */
+  renderView(e, t, i = null) {
+    if (this.disposed) return;
+    this.lastRenderer = t, e.updateMatrixWorld(), this.updateWorldMatrix(!0, !1), this.flushPendingUploads(t), i ? P.set(i.width, i.height) : t.getDrawingBufferSize(P), this.writeViewUniforms(e, P.x, P.y);
+    const s = this.sortForView(e, t), r = t.getRenderTarget();
+    try {
+      t.setRenderTarget(i), t.render(this, e);
+    } finally {
+      t.setRenderTarget(r), s && (this.orderIsForeign = !0);
+    }
+  }
+  /**
+   * Sorts the shared order buffer for a secondary view's camera, bypassing the
+   * primary view's sort scheduler and its `lastSortedModelView` record (that
+   * state belongs to `update()`'s camera). WebGPU dispatches synchronously into
+   * the render queue, so the following draw reads this order.
+   */
+  sortForView(e, t) {
+    return this.activeCount === 0 || !(t.backend.isWebGPUBackend === !0) || (this.currentModelView.multiplyMatrices(e.matrixWorldInverse, this.matrixWorld), this.refreshSortBounds(), this.sorter ?? (this.sorter = this.createSorter(t)), !this.sorter) ? !1 : (this.sorter.sort(this.currentModelView, this.activeCount, this.boundingSphereLocal), !0);
+  }
+  /** Rebuilds the query grid if the resident set changed since it was built. */
+  ensureQueryGrid() {
+    if (this.queryGrid && this.queryGridEpoch === this.queryEpoch) return this.queryGrid;
+    const e = this.sourceIndexAttribute.array.subarray(0, this.activeCount);
+    return this.queryGrid = new $t(this.backing.centers, e, this.activeCount), this.queryGridEpoch = this.queryEpoch, this.queryGrid;
+  }
+  /** World-space position of pool splat `poolIndex`, written into `out`. */
+  splatWorldPosition(e, t) {
+    const i = e * 4;
+    return t.set(
+      this.backing.centers[i],
+      this.backing.centers[i + 1],
+      this.backing.centers[i + 2]
+    ), t.applyMatrix4(this.matrixWorld);
+  }
+  /**
+   * The smallest world axis scale, for conservatively mapping a world radius
+   * into local space: a world sphere of radius `r` fits inside a local sphere
+   * of `r / minAxisScale`, for any per-axis (non-uniform) scale.
+   */
+  queryWorldMinScale() {
+    return this.getWorldScale(q), Math.min(Math.abs(q.x), Math.abs(q.y), Math.abs(q.z)) || 1;
+  }
+  /**
+   * Releases every GPU resource and worker this mesh owns. Idempotent: a
+   * second call is a no-op, and a render loop that outlives the mesh by a
+   * frame is safe - {@link update}, {@link renderView} and {@link pick} all
+   * become no-ops after dispose.
+   */
+  dispose() {
+    var e;
+    if (!this.disposed) {
+      this.disposed = !0, (e = this.sorter) == null || e.dispose(), this.sorter = null, this.geometry.dispose(), this.material.dispose(), this.picker.dispose(), this.relightPlaceholder.dispose();
+      for (const t of this.ranges.values())
+        this.pool.releaseRows(t.startRow, t.rowCount);
+      this.pool.unregister(this), this.ownsPool && this.pool.dispose();
+      for (const t of this.dataTextures)
+        !this.ownsPool && this.pool.isPoolTexture(t) || t.dispose();
+      for (const t of this.channels.values()) t.texture.dispose();
+      this.channels.clear();
+      for (const t of this.uploadStaging.values())
+        for (const i of t.values()) i.dispose();
+      this.uploadStaging.clear(), this.halfEncodeBuffers.clear(), this.lastRenderer && (Ut(this.lastRenderer, [this.sourceIndexAttribute]), this.lastRenderer = null), this.pendingUploadRows = [], this.workerDirtyRows = [], this.queryGrid = null, this.ranges.clear();
+    }
+  }
+  /** Matches the viewport / focal / local-camera uniforms written by {@link update}. */
+  refreshProjectionUniforms(e, t) {
+    t.getDrawingBufferSize(P), this.writeViewUniforms(e, P.x, P.y);
+  }
+  /**
+   * Writes the three view-dependent uniforms - viewport, focal (splat screen
+   * size), and the camera position in mesh-local space (SH view direction +
+   * screen-radius math) - for a camera drawing into a viewport of the given
+   * pixel size. {@link update} passes the canvas size (or, while an XR session
+   * presents, the per-eye viewport); {@link renderView} passes its render
+   * target's size.
+   *
+   * @param positionCamera - Camera whose world position seeds the SH view
+   * direction and screen-radius math. Defaults to `camera`; in XR it is the
+   * head, so both eyes shade from one cyclopean point while each still
+   * projects through its own eye.
+   */
+  writeViewUniforms(e, t, i, s = e) {
+    this.viewport.value.set(t, i);
+    const r = e.projectionMatrix.elements, n = r[5] * i / 2;
+    this.focal.value.set(r[0] * t / 2, n), s.getWorldPosition(this.localCameraPosition.value), this.worldToLocal(this.localCameraPosition.value), this.foveationMode === "frontier" && n > 0 && (this.pixelScaleLimit.value = this.foveationLimitPx / n);
+  }
+  /**
+   * Self-adjusts {@link foveationLimitPx} so the frontier cut's drawn-splat count
+   * tracks {@link foveationDrawBudget} (Spark's `maxSplats` feedback). Estimates
+   * the drawn count by replaying the cut on a strided sample of the pool, then
+   * coarsens (grows the limit) when over budget and refines (shrinks toward the
+   * finest {@link foveationTargetPx}) when comfortably under. Throttled; a no-op
+   * outside `'frontier'` mode.
+   *
+   * `viewportY` must be the **same** height {@link writeViewUniforms} is given
+   * for this frame - the two share `foveationLimitPx` in pixels and each
+   * converts it with its own `focalY`, so a mismatch (the full drawing buffer
+   * here against a per-eye viewport there) makes the estimator judge a cut the
+   * shader is not applying, and the ratchet runs away toward the maximum.
+   */
+  adaptFoveationLimit(e, t) {
+    if (this.foveationMode !== "frontier") return;
+    const i = performance.now();
+    if (i - this.lastFoveationAdaptAt < Kt) return;
+    this.lastFoveationAdaptAt = i;
+    const s = e.projectionMatrix.elements[5] * t / 2;
+    if (!(s > 0)) return;
+    const r = this.foveationLimitPx / s;
+    e.getWorldPosition(_), this.worldToLocal(_), ot.copy(e.matrixWorld).invert(), at.multiplyMatrices(ot, this.matrixWorld).premultiply(e.projectionMatrix);
+    const n = at.elements, { covarianceA: a, covarianceB: c, centers: h } = this.backing, l = c.length / 4;
+    let f = 0, x = 0;
+    for (let m = 0; m < l; m += ht) {
+      const S = m * 4, A = c[S + 3];
+      if (A === 0) continue;
+      f++;
+      const R = h[S], y = h[S + 1], M = h[S + 2], I = (n[3] * R + n[7] * y + n[11] * M + n[15]) * 1.2;
+      if (n[2] * R + n[6] * y + n[10] * M + n[14] <= -I) continue;
+      const B = n[0] * R + n[4] * y + n[8] * M + n[12];
+      if (B > I || B < -I) continue;
+      const E = n[1] * R + n[5] * y + n[9] * M + n[13];
+      if (E > I || E < -I) continue;
+      const W = a[S] + a[S + 3] + c[S + 1], L = 2 * Math.sqrt(Math.max(W, 0) / 3), C = A < 0, ut = Math.abs(A), N = R - _.x, X = y - _.y, j = M - _.z, $ = r * Math.sqrt(N * N + X * X + j * j), dt = C ? 0 : L;
+      ut > $ && dt <= $ && x++;
+    }
+    if (f === 0) return;
+    const p = x * ht, w = this.foveationDrawBudget;
+    p > w * 1.1 ? this.foveationLimitPx = Math.min(this.foveationLimitPx * 1.15, Qt) : p < w * 0.7 && (this.foveationLimitPx = Math.max(this.foveationLimitPx / 1.12, this.foveationTargetPx));
+  }
+  /** Records a written row span for GPU upload and the sort-worker mirror. */
+  markRowsWritten(e, t) {
+    var i;
+    this.pendingUploadRows.push({ start: e, count: t }), ((i = this.sorter) == null ? void 0 : i.kind) === "worker" && this.workerDirtyRows.push({ start: e, count: t });
+  }
+  /** Appends one newly active pool range to the packed source-index list. */
+  activateRecord(e) {
+    const t = e.activePrefix ?? e.count;
+    if (t === 0) return;
+    this.queryEpoch++;
+    const i = this.sourceIndexAttribute.array, s = this.getPoolIndexTemplate(), r = this.activeCount;
+    i.set(s.subarray(e.start, e.start + t), r), this.activeSlotByPoolIndex.set(
+      s.subarray(r, r + t),
+      e.start
+    ), this.activeCount += t, this.commitActiveListMutation(r, t);
+  }
+  /**
+   * Removes one active range and backfills its holes from the packed tail.
+   * The common contiguous case uses one native block copy; the fallback
+   * handles a range split by earlier tail backfills in O(record.count).
+   */
+  deactivateRecord(e) {
+    const t = e.activePrefix ?? e.count;
+    if (t === 0) return;
+    this.queryEpoch++;
+    const i = this.sourceIndexAttribute.array, s = this.activeSlotByPoolIndex[e.start];
+    let r = !0;
+    for (let c = 1; c < t; c++)
+      if (this.activeSlotByPoolIndex[e.start + c] !== s + c) {
+        r = !1;
+        break;
+      }
+    let n = this.activeCount, a = 0;
+    if (r) {
+      const c = this.activeCount - t, h = Math.min(t, Math.max(0, c - s));
+      if (h > 0) {
+        i.copyWithin(s, this.activeCount - h, this.activeCount);
+        for (let l = 0; l < h; l++) {
+          const f = i[s + l];
+          this.activeSlotByPoolIndex[f] = s + l;
+        }
+        n = s, a = s + h;
+      }
+      this.activeCount = c;
+    } else {
+      for (let c = e.start; c < e.start + t; c++) {
+        const h = this.activeSlotByPoolIndex[c], l = this.activeCount - 1;
+        if (h !== l) {
+          const f = i[l];
+          i[h] = f, this.activeSlotByPoolIndex[f] = h, n = Math.min(n, h), a = Math.max(a, h + 1);
+        }
+        this.activeCount--;
+      }
+      a = Math.min(a, this.activeCount);
+    }
+    this.commitActiveListMutation(n, Math.max(0, a - n));
+  }
+  /** Uploads only the changed packed slots and invalidates the current depth order. */
+  commitActiveListMutation(e, t) {
+    var i;
+    if (t > 0 && (z(this.sourceIndexAttribute, e, t), this.sourceIndexAttribute.needsUpdate = !0), ((i = this.sorter) == null ? void 0 : i.kind) === "worker" || this.sorter === null) {
+      const s = this.sourceIndexAttribute.array, r = this.splatIndexAttribute.array;
+      this.drawListSorted ? (r.set(s.subarray(0, this.activeCount)), this.activeCount > 0 && z(this.splatIndexAttribute, 0, this.activeCount), this.splatIndexAttribute.needsUpdate = !0, this.drawListSorted = !1) : t > 0 && (r.set(s.subarray(e, e + t), e), z(this.splatIndexAttribute, e, t), this.splatIndexAttribute.needsUpdate = !0);
+    }
+    this.geometry.instanceCount = this.activeCount, this.activeListVersion++, this.sortScheduler.invalidateContent();
+  }
+  /** Rewrites the active-splat list (pool indices, range by range). */
+  rebuildActiveList() {
+    var s;
+    const e = this.sourceIndexAttribute.array, t = this.getPoolIndexTemplate();
+    let i = 0;
+    for (const r of this.ranges.values()) {
+      if (!r.active) continue;
+      const n = r.activePrefix ?? r.count;
+      e.set(t.subarray(r.start, r.start + n), i), this.activeSlotByPoolIndex.set(t.subarray(i, i + n), r.start), i += n;
+    }
+    this.activeCount = i, this.sourceIndexAttribute.clearUpdateRanges(), i > 0 && this.sourceIndexAttribute.addUpdateRange(0, i), this.sourceIndexAttribute.needsUpdate = !0, (((s = this.sorter) == null ? void 0 : s.kind) === "worker" || this.sorter === null) && (this.splatIndexAttribute.array.set(e.subarray(0, i)), this.splatIndexAttribute.clearUpdateRanges(), i > 0 && this.splatIndexAttribute.addUpdateRange(0, i), this.splatIndexAttribute.needsUpdate = !0, this.drawListSorted = !1), this.geometry.instanceCount = i, this.activeListVersion++, this.sortScheduler.invalidateContent();
+  }
+  /** The pool's reusable index ramp; shared by every mesh drawing from it. */
+  getPoolIndexTemplate() {
+    return this.pool.indexTemplate();
+  }
+  /**
+   * Uploads rows written since the last flush by copying only those rows
+   * through a staging texture. (Constructor-time writes never appear here;
+   * they ride the textures' initial full upload instead.)
+   */
+  flushPendingUploads(e) {
+    if (this.pendingUploadRows.length > 0) {
+      const t = this.poolFloatTextures === "float16" ? d.HalfFloatType : d.FloatType;
+      this.uploadRows(e, this.pendingUploadRows, d.RGBAFormat, 4, [
+        {
+          key: "centers",
+          texture: this.dataTextures[0],
+          data: this.backing.centers,
+          type: t,
+          encodeHalf: this.poolFloatTextures === "float16"
+        },
+        {
+          key: "colors",
+          texture: this.dataTextures[1],
+          data: this.backing.colors,
+          type: d.UnsignedByteType
+        },
+        {
+          key: "covarianceA",
+          texture: this.dataTextures[2],
+          data: this.backing.covarianceA,
+          type: t,
+          encodeHalf: this.poolFloatTextures === "float16"
+        },
+        {
+          key: "covarianceB",
+          texture: this.dataTextures[3],
+          data: this.backing.covarianceB,
+          type: d.FloatType
+        }
+      ]), this.shPackedTextures.length > 0 && this.uploadRows(
+        e,
+        this.pendingUploadRows,
+        d.RGBAIntegerFormat,
+        4,
+        this.shPackedTextures.map((i, s) => ({
+          key: `shPacked${s}`,
+          texture: i,
+          data: this.backing.shPacked[s],
+          type: d.UnsignedIntType
+        }))
+      ), this.pendingUploadRows = [];
+    }
+    for (const [t, i] of this.channels.entries())
+      i.pendingRows.length !== 0 && (this.uploadRows(e, i.pendingRows, d.RedFormat, 1, [
+        {
+          key: `channel:${t}`,
+          texture: i.texture,
+          data: i.backing,
+          type: i.textureType
+        }
+      ]), i.pendingRows = []);
+  }
+  /**
+   * Packs float32 CPU backing into the half GPU images for centers/covA.
+   * Used once after a static constructor write so the initial `needsUpdate`
+   * upload carries half bits (staging is skipped for that path).
+   */
+  syncHalfFloatPoolImages() {
+    const e = this.dataTextures[0], t = this.dataTextures[2], i = e.image.data, s = t.image.data;
+    G(this.backing.centers, i), G(this.backing.covarianceA, s), e.needsUpdate = !0, t.needsUpdate = !0;
+  }
+  /**
+   * Uploads the given row spans of one or more same-layout pool textures via
+   * per-region staging copies. Spans are merged first so consecutive appends
+   * upload as one rectangle each - the copyTextureToTexture call count, not
+   * the pixel volume, dominates.
+   */
+  uploadRows(e, t, i, s, r) {
+    const n = v.DATA_TEXTURE_WIDTH, a = t.sort((h, l) => h.start - l.start), c = [];
+    for (const h of a) {
+      const l = c[c.length - 1];
+      l && h.start <= l.start + l.count ? l.count = Math.max(l.count, h.start + h.count - l.start) : c.push({ start: h.start, count: h.count });
+    }
+    for (const h of c)
+      for (const { key: l, texture: f, data: x, type: p, encodeHalf: w } of r) {
+        const m = x.subarray(
+          h.start * n * s,
+          (h.start + h.count) * n * s
+        );
+        let S = m;
+        if (w) {
+          const R = this.acquireHalfEncodeBuffer(l, m.length);
+          G(m, R, 0, m.length), S = R;
+        }
+        const A = this.acquireUploadStaging(
+          l,
+          S,
+          n,
+          h.count,
+          i,
+          p
+        );
+        e.copyTextureToTexture(A, f, null, Zt.set(0, h.start));
+      }
+  }
+  /** Reuses a same-length half encode buffer for one staging key. */
+  acquireHalfEncodeBuffer(e, t) {
+    const i = this.halfEncodeBuffers.get(e);
+    if (i && i.length === t) return i;
+    const s = new Uint16Array(t);
+    return this.halfEncodeBuffers.set(e, s), s;
+  }
+  /**
+   * Reuses one of the recent same-sized staging textures for this upload. WebGPU
+   * texture dimensions are immutable, so each cached entry remains exact-sized. Keeping
+   * a small LRU per channel avoids recreating all core/SH staging resources when
+   * a stream alternates among a few chunk heights, while bounding GPU memory.
+   */
+  acquireUploadStaging(e, t, i, s, r, n) {
+    var l;
+    let a = this.uploadStaging.get(e);
+    a || (a = /* @__PURE__ */ new Map(), this.uploadStaging.set(e, a));
+    const c = a.get(s);
+    if (c)
+      return c.image = { data: t, width: i, height: s }, c.needsUpdate = !0, a.delete(s), a.set(s, c), c;
+    const h = new d.DataTexture(t, i, s, r, n);
+    if (r === d.RGBAIntegerFormat && (h.magFilter = d.NearestFilter, h.minFilter = d.NearestFilter), h.needsUpdate = !0, a.set(s, h), a.size > Yt) {
+      const f = a.keys().next().value;
+      (l = a.get(f)) == null || l.dispose(), a.delete(f);
+    }
+    return this.updateTimings.stagingTextureAllocations++, h;
+  }
+  /** Gathers everything the material graph reads. See `splat-mesh-material.ts`. */
+  graphInputs(e, t) {
+    return {
+      textures: e,
+      sh: t,
+      sourcePlacement: this.perSourceSort,
+      // The uniform node instances, shared with the pick graph on purpose: one
+      // per-frame write then reaches both.
+      uniforms: {
+        focal: this.focal,
+        viewport: this.viewport,
+        localCameraPosition: this.localCameraPosition,
+        pixelScaleLimit: this.pixelScaleLimit,
+        dofFocusDistance: this.dofFocusDistance,
+        dofAperture: this.dofAperture,
+        screenBandMin: this.screenBandMin,
+        screenBandMax: this.screenBandMax,
+        relightMap: this.relightMap,
+        relightBlend: this.relightBlend,
+        relightBrightness: this.relightBrightness,
+        relightBackground: this.relightBackground,
+        relightSoftness: this.relightSoftness
+      },
+      pick: this.picker.uniforms,
+      settings: {
+        maxStdDev: this.maxStdDev,
+        minSplatSizePx: this.minSplatSizePx,
+        antialias: this.antialias,
+        projectedFilterProfile: this.projectedFilterProfile,
+        srgbOutput: this.srgbOutput,
+        performanceProfile: this.performanceProfileValue,
+        maxScreenRadiusPx: this.maxSplatScreenRadius,
+        minScreenRadiusPx: this.minSplatScreenRadius,
+        foveationMode: this.foveationMode,
+        maxAspect: this.maxSplatAspect,
+        lodAlpha: this.lodAlpha
+      },
+      // The live map: a rebuild after defineChannel must see the new entry.
+      channels: this.channels,
+      modifiers: this.modifierList
+    };
+  }
+  buildMaterial(e, t) {
+    Z(
+      this.material,
+      "display",
+      this.graphInputs(e, t)
+    ), this.picker.rebuildMaterial();
+  }
+  requestSortIfNeeded(e, t) {
+    if (this.deferSortRequestOnce && (this.deferSortRequestOnce = !1, this.activeListVersion === this.sortedActiveListVersion && !this.orderIsForeign) || this.activeCount === 0) return;
+    this.currentModelView.multiplyMatrices(e.matrixWorldInverse, this.matrixWorld);
+    const i = t.backend.isWebGPUBackend === !0, s = i ? performance.now() : 0;
+    if (!this.orderIsForeign) {
+      if (i) {
+        if (!this.sortScheduler.shouldSubmit(
+          this.currentModelView,
+          this.lastSortedModelView,
+          this.activeCount,
+          s
+        ))
+          return;
+      } else if (
+        // WebGL2 has no cadence, but a content swap under a stationary camera
+        // still invalidated the draw order (the swap reset it to unsorted
+        // active order) - skipping here would leave the scene blend-order
+        // broken until the camera next moved.
+        !this.sortScheduler.hasPendingForce() && this.currentModelView.equals(this.lastSortedModelView)
+      )
+        return;
+    }
+    this.refreshSortBounds(), this.sorter ?? (this.sorter = this.createSorter(t)), this.sorter && this.sorter.sort(this.currentModelView, this.activeCount, this.boundingSphereLocal) && (this.lastSortedModelView.copy(this.currentModelView), this.sortedActiveListVersion = this.activeListVersion, this.orderIsForeign = !1, this.sortScheduler.markAccepted(s));
+  }
+  /**
+   * Refreshes {@link boundingSphereLocal} - the sphere the sorter quantizes
+   * depth over - when {@link boundsDirty}. The base mesh uses its local splat
+   * bounds; a unified {@link MergedSplatMesh} overrides this to supply a world-space
+   * bound spanning all its sources (whose transforms live in the shader).
+   */
+  refreshSortBounds() {
+    this.boundsDirty && (this.localBounds.getBoundingSphere(this.boundingSphereLocal), this.boundsDirty = !1);
+  }
+  /** The data texture backing a channel defined with {@link defineChannel}. */
+  channelTexture(e) {
+    var t;
+    return (t = this.channels.get(e)) == null ? void 0 : t.texture;
+  }
+  /** CPU backing storage of a float channel, for internal CPU-side consumers. */
+  channelBacking(e) {
+    const t = this.channels.get(e);
+    if (!t || !(t.backing instanceof Float32Array))
+      throw new Error(`SplatMesh: float channel "${e}" is missing.`);
+    return t.backing;
+  }
+  /**
+   * Forces the next {@link update} to re-sort even if the camera has not moved
+   * - used by a unified pool when a source's transform changes, since the depth
+   * order then changes without any camera motion.
+   */
+  invalidateSort() {
+    this.sortScheduler.invalidate(), this.boundsDirty = !0;
+  }
+  createSorter(e) {
+    if (!(e.backend.isWebGPUBackend === !0))
+      return new qt({
+        capacity: this.capacity,
+        rowWidth: v.DATA_TEXTURE_WIDTH,
+        centers: this.backing.centers,
+        perSource: this.perSourceSort ? {
+          sourceIds: this.perSourceSort.sourceIds,
+          matrices: this.perSourceSort.matrices
+        } : void 0,
+        splatIndexAttribute: this.splatIndexAttribute,
+        takeDirtyRows: () => {
+          const s = this.workerDirtyRows;
+          return this.workerDirtyRows = [], s;
+        },
+        getActiveSpans: () => {
+          const s = new Uint32Array(this.ranges.size * 2);
+          let r = 0;
+          for (const n of this.ranges.values()) {
+            if (!n.active) continue;
+            const a = n.activePrefix ?? n.count;
+            a !== 0 && (s[r++] = n.start, s[r++] = a);
+          }
+          return s.subarray(0, r);
+        },
+        onOrderApplied: () => {
+          this.drawListSorted = !0;
+        }
+      });
+    const i = {
+      renderer: e,
+      capacity: this.poolRows * v.DATA_TEXTURE_WIDTH,
+      centersTexture: this.centersTexture,
+      dataTextureWidth: v.DATA_TEXTURE_WIDTH,
+      splatIndexAttribute: this.splatIndexAttribute,
+      sourceIndexAttribute: this.sourceIndexAttribute
+    };
+    return this.perSourceSort ? new tt({ ...i, perSource: this.perSourceSort }) : this.sortStrategy === "radix" || this.sortStrategy === "exact" ? (this.ensureRadixSorter(), this.RadixSorterCtor ? new this.RadixSorterCtor({ ...i, exactDepth: this.sortStrategy === "exact" }) : null) : new tt(i);
+  }
+  /** Prefetches the experimental radix sorter; safe to call repeatedly. */
+  ensureRadixSorter() {
+    this.RadixSorterCtor || this.radixSorterLoad || (this.radixSorterLoad = import("./radix-sorter-R0FCSqKu.js").then((e) => {
+      this.RadixSorterCtor = e.RadixSorter;
+    }).finally(() => {
+      this.radixSorterLoad = null;
+    }));
+  }
+};
+o(v, "DATA_TEXTURE_WIDTH", xt);
+let nt = v;
+const F = new d.Box3(), Zt = new d.Vector2(), T = new d.Vector3(), k = new d.Vector3(), q = new d.Vector3(), P = new d.Vector2(), _ = new d.Vector3(), ot = new d.Matrix4(), at = new d.Matrix4(), Kt = 180, ht = 31, Qt = 64;
+function ct(g) {
+  if (g !== void 0 && (!Number.isFinite(g) || g <= 0))
+    throw new RangeError("SplatMesh maxStdDev must be a finite number greater than 0.");
+  return g;
+}
+function Jt(g) {
+  if (g !== void 0 && (!Number.isFinite(g) || g < 0))
+    throw new RangeError("SplatMesh minSplatSizePx must be a finite number >= 0.");
+  return g;
+}
+function H(g) {
+  if (g === void 0) return 0;
+  if (!Number.isFinite(g) || g < 0)
+    throw new RangeError("SplatMesh screen-radius cull must be a finite number ≥ 0.");
+  return g;
+}
+const te = 1;
+function ee(g) {
+  if (g === void 0) return te;
+  if (!Number.isFinite(g) || g <= 0)
+    throw new RangeError("SplatMesh foveationTargetPx must be a finite number > 0.");
+  return g;
+}
+const ie = 9e5;
+function se(g) {
+  if (g === void 0) return ie;
+  if (!Number.isFinite(g) || g <= 0)
+    throw new RangeError("SplatMesh foveationDrawBudget must be a finite number > 0.");
+  return g;
+}
+export {
+  ie as D,
+  nt as S,
+  te as a,
+  Ft as c,
+  Vt as y
+};
+//# sourceMappingURL=splat-mesh-aQdcWA6v.js.map