@voluma/vlam 0.1.0 → 0.2.0

package/dist/static-lod-worker-D2fyqQZO.js

@@ -0,0 +1,474 @@
+const a = `var at = Object.defineProperty;
+var it = (t, n, o) => n in t ? at(t, n, { enumerable: !0, configurable: !0, writable: !0, value: o }) : t[n] = o;
+var Z = (t, n, o) => it(t, typeof n != "symbol" ? n + "" : n, o);
+const lt = {
+  coneFov0: 90,
+  coneFov: 120,
+  coneFoveate: 0.4,
+  behindFoveate: 0.2
+};
+function rt(t, n, o = lt) {
+  return {
+    origin: t,
+    ...n ? { forward: n } : {},
+    coneDot0: o.coneFov0 > 0 ? Math.cos(0.5 * o.coneFov0 * Math.PI / 180) : 1,
+    coneDot: o.coneFov > 0 ? Math.cos(0.5 * o.coneFov * Math.PI / 180) : 1,
+    coneFoveate: o.coneFoveate,
+    behindFoveate: o.behindFoveate
+  };
+}
+function ht(t, n, o, s, e, i = Number.POSITIVE_INFINITY) {
+  const c = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), l = new ft(), p = s.origin.x, h = s.origin.y, f = s.origin.z, r = s.forward, a = (r == null ? void 0 : r.x) ?? 0, M = (r == null ? void 0 : r.y) ?? 0, b = (r == null ? void 0 : r.z) ?? 0, N = r !== void 0, { coneDot0: S, coneDot: v, coneFoveate: F, behindFoveate: A } = s, R = (y) => {
+    const d = Math.floor(y / o), m = t.get(d);
+    return !m || !m.radTree ? null : { data: m, local: y - d * o };
+  }, D = (y, d) => {
+    let m = c.get(y);
+    m || (m = [], c.set(y, m)), m.push(d);
+  }, V = (y, d) => {
+    const m = y.positions, P = d * 3, E = m[P] - p, C = m[P + 1] - h, O = m[P + 2] - f, x = Math.sqrt(E * E + C * C + O * O) || 1e-6, U = y.radTree.size[d] / x;
+    if (!N) return U;
+    const I = E * a + C * M + O * b;
+    if (I <= 0) return U * A;
+    const T = I / x;
+    if (T >= S) return U;
+    if (T >= v) {
+      const L = (T - v) / (S - v);
+      return U * (F + (1 - F) * L);
+    }
+    return U * (A + (F - A) * (T / v));
+  };
+  let _ = 0;
+  const $ = /* @__PURE__ */ new Set();
+  for (const y of n) {
+    if ($.has(y)) continue;
+    const d = R(y);
+    d && ($.add(y), l.push(y, V(d.data, d.local)), _++);
+  }
+  let k = !1;
+  for (; l.size > 0; ) {
+    const y = l.peekPriority();
+    if (y <= e) break;
+    const d = l.peek(), m = R(d);
+    if (!m) {
+      l.pop(), _--;
+      continue;
+    }
+    const P = Math.floor(d / o), E = m.data.radTree, C = E.childCount[m.local];
+    if (C === 0) {
+      l.pop(), D(P, m.local);
+      continue;
+    }
+    const O = _ - 1 + C;
+    if (O > i) {
+      k = !0;
+      break;
+    }
+    l.pop();
+    const x = E.childStart[m.local], U = Math.floor(x / o), I = Math.floor((x + C - 1) / o);
+    let T = !0;
+    for (let L = U; L <= I; L++)
+      t.has(L) || (T = !1, y > (u.get(L) ?? 0) && u.set(L, y));
+    if (!T) {
+      D(P, m.local);
+      continue;
+    }
+    for (let L = 0; L < C; L++) {
+      const K = x + L, X = R(K), Q = V(X.data, X.local);
+      Q <= e ? D(Math.floor(K / o), X.local) : l.push(K, Q);
+    }
+    _ = O;
+  }
+  let w = !1;
+  for (; l.size > 0; ) {
+    const y = l.pop(), d = Math.floor(y / o), m = y - d * o;
+    if (D(d, m), !w) {
+      const P = t.get(d), E = P == null ? void 0 : P.radTree, C = E ? E.childCount[m] : 0;
+      if (C > 0) {
+        const O = E.childStart[m], x = Math.floor(O / o), U = Math.floor((O + C - 1) / o);
+        let I = !0;
+        for (let T = x; T <= U && I; T++)
+          t.has(T) || (I = !1);
+        I && (w = !0);
+      }
+    }
+  }
+  const G = /* @__PURE__ */ new Map();
+  let Y = 0;
+  for (const [y, d] of c)
+    G.set(y, Uint32Array.from(d)), Y += d.length;
+  return { selection: G, count: Y, touched: u, budgetClamped: k, refinable: w };
+}
+class ft {
+  constructor() {
+    Z(this, "items", []);
+    // global indices
+    Z(this, "prio", []);
+  }
+  get size() {
+    return this.items.length;
+  }
+  /** Largest-priority item, without removing it. Undefined when empty. */
+  peek() {
+    return this.items[0];
+  }
+  /** Priority of {@link peek}. */
+  peekPriority() {
+    return this.prio[0];
+  }
+  push(n, o) {
+    const s = this.items, e = this.prio;
+    let i = s.length;
+    for (s.push(n), e.push(o); i > 0; ) {
+      const c = i - 1 >> 1;
+      if (e[c] >= o) break;
+      s[i] = s[c], e[i] = e[c], s[c] = n, e[c] = o, i = c;
+    }
+  }
+  pop() {
+    const n = this.items, o = this.prio, s = n[0], e = n.pop(), i = o.pop();
+    if (n.length > 0) {
+      n[0] = e, o[0] = i;
+      const c = n.length;
+      let u = 0;
+      for (; ; ) {
+        const l = 2 * u + 1, p = l + 1;
+        let h = u;
+        if (l < c && o[l] > o[h] && (h = l), p < c && o[p] > o[h] && (h = p), h === u) break;
+        const f = n[u], r = o[u];
+        n[u] = n[h], o[u] = o[h], n[h] = f, o[h] = r, u = h;
+      }
+    }
+    return s;
+  }
+}
+function nt(t) {
+  return [0, 3, 8, 15][t] ?? 0;
+}
+const ot = 10, z = 1 << ot, q = 1e-18, st = (t, n) => {
+  const o = n * 6, s = t[o], e = t[o + 1], i = t[o + 2], c = t[o + 3], u = t[o + 4], l = t[o + 5];
+  return s * (c * l - u * u) - e * (e * l - u * i) + i * (e * u - c * i);
+}, pt = (t, n, o) => {
+  const s = t[o * 4 + 3] / 255, e = Math.sqrt(Math.max(q, st(n, o)));
+  return Math.max(q, s * e);
+}, et = (t, n) => {
+  const o = n * 6, s = t[o] + t[o + 3] + t[o + 5];
+  return 2 * Math.sqrt(Math.max(q, s));
+}, W = (t) => {
+  let n = t & 1023;
+  return n = (n | n << 16) & 50331903, n = (n | n << 8) & 50393103, n = (n | n << 4) & 51130563, n = (n | n << 2) & 153391689, n >>> 0;
+}, ut = (t, n, o) => (W(t) | W(n) << 1 | W(o) << 2) >>> 0, dt = (t, n) => {
+  const o = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY], s = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  for (let p = 0; p < n; p++) {
+    const h = p * 3;
+    for (let f = 0; f < 3; f++) {
+      const r = t[h + f];
+      o[f] = Math.min(o[f], r), s[f] = Math.max(s[f], r);
+    }
+  }
+  let e = new Uint32Array(n), i = new Uint32Array(n), c = new Uint32Array(n), u = new Uint32Array(n);
+  const l = o.map(
+    (p, h) => (z - 1) / Math.max(1e-12, s[h] - p)
+  );
+  for (let p = 0; p < n; p++) {
+    const h = p * 3, f = Math.max(
+      0,
+      Math.min(
+        z - 1,
+        Math.floor((t[h] - o[0]) * l[0])
+      )
+    ), r = Math.max(
+      0,
+      Math.min(
+        z - 1,
+        Math.floor((t[h + 1] - o[1]) * l[1])
+      )
+    ), a = Math.max(
+      0,
+      Math.min(
+        z - 1,
+        Math.floor((t[h + 2] - o[2]) * l[2])
+      )
+    );
+    e[p] = p, c[p] = ut(f, r, a);
+  }
+  for (let p = 0; p < 30; p += ot) {
+    const h = new Uint32Array(z);
+    for (let r = 0; r < n; r++) {
+      const a = c[r] >>> p & z - 1;
+      h[a] = h[a] + 1;
+    }
+    let f = 0;
+    for (let r = 0; r < h.length; r++) {
+      const a = h[r];
+      h[r] = f, f += a;
+    }
+    for (let r = 0; r < n; r++) {
+      const a = c[r], M = a >>> p & z - 1, b = h[M];
+      h[M] = b + 1, u[b] = a, i[b] = e[r];
+    }
+    [c, u] = [u, c], [e, i] = [i, e];
+  }
+  return e;
+};
+function J(t) {
+  if (!Number.isSafeInteger(t.count) || t.count < 0)
+    throw new RangeError(
+      \`Static LOD source count must be a non-negative safe integer; received \${t.count}.\`
+    );
+  const n = [
+    ["positions", t.positions.length, t.count * 3],
+    ["colors", t.colors.length, t.count * 4],
+    ["covariances", t.covariances.length, t.count * 6]
+  ];
+  t.sh && n.push(["sh.labels", t.sh.labels.length, t.count]);
+  for (const [e, i, c] of n)
+    if (i !== c)
+      throw new RangeError(
+        \`Static LOD source is structurally inconsistent: \${e} has \${i} entries; expected \${c} for \${t.count} splats.\`
+      );
+  if (!t.shPacked) return;
+  const o = nt(t.shPacked.bands), s = t.count * o;
+  if (t.shPacked.packed.length !== s)
+    throw new RangeError(
+      \`Static LOD source is structurally inconsistent: shPacked.packed has \${t.shPacked.packed.length} words; expected \${s} (\${t.count} splats × \${o} coefficients for \${t.shPacked.bands} SH bands).\`
+    );
+}
+const B = (t) => t.shPacked ? nt(t.shPacked.bands) : 0, mt = (t, n) => ({
+  count: t,
+  positions: new Float32Array(t * 3),
+  colors: new Uint8Array(t * 4),
+  covariances: new Float32Array(t * 6),
+  masses: new Float64Array(t),
+  sizes: new Float32Array(t),
+  ...n.sh ? { shLabels: new Uint32Array(t) } : {},
+  ...n.shPacked ? {
+    shPacked: new Uint32Array(t * B(n)),
+    packedStride: B(n)
+  } : {},
+  dominant: new Uint32Array(t)
+}), g = (t, n, o, s) => {
+  if (o.positions.set(
+    t.positions.subarray(n * 3, n * 3 + 3),
+    s * 3
+  ), o.colors.set(t.colors.subarray(n * 4, n * 4 + 4), s * 4), o.covariances.set(
+    t.covariances.subarray(n * 6, n * 6 + 6),
+    s * 6
+  ), o.masses[s] = pt(t.colors, t.covariances, n), o.sizes[s] = et(t.covariances, n), o.dominant[s] = n, o.shLabels && t.sh && (o.shLabels[s] = t.sh.labels[n]), o.shPacked && t.shPacked) {
+    const e = B(t);
+    o.shPacked.set(
+      t.shPacked.packed.subarray(n * e, (n + 1) * e),
+      s * e
+    );
+  }
+}, ct = (t, n, o, s, e) => {
+  let i = 0, c = n, u = -1;
+  const l = [0, 0, 0], p = [0, 0, 0];
+  for (let a = n; a < o; a++) {
+    const M = t.masses[a];
+    i += M, M > u && (u = M, c = a);
+    for (let b = 0; b < 3; b++)
+      l[b] = l[b] + t.positions[a * 3 + b] * M, p[b] = p[b] + t.colors[a * 4 + b] * M;
+  }
+  const h = Math.max(i, q);
+  for (let a = 0; a < 3; a++)
+    l[a] = l[a] / h, s.positions[e * 3 + a] = l[a], s.colors[e * 4 + a] = Math.max(
+      0,
+      Math.min(255, Math.round(p[a] / h))
+    );
+  const f = [0, 0, 0, 0, 0, 0];
+  for (let a = n; a < o; a++) {
+    const M = t.masses[a], b = t.positions[a * 3] - l[0], N = t.positions[a * 3 + 1] - l[1], S = t.positions[a * 3 + 2] - l[2], v = a * 6;
+    f[0] = f[0] + (t.covariances[v] + b * b) * M, f[1] = f[1] + (t.covariances[v + 1] + b * N) * M, f[2] = f[2] + (t.covariances[v + 2] + b * S) * M, f[3] = f[3] + (t.covariances[v + 3] + N * N) * M, f[4] = f[4] + (t.covariances[v + 4] + N * S) * M, f[5] = f[5] + (t.covariances[v + 5] + S * S) * M;
+  }
+  for (let a = 0; a < 6; a++)
+    s.covariances[e * 6 + a] = f[a] / h;
+  s.masses[e] = i;
+  const r = Math.sqrt(
+    Math.max(q, st(s.covariances, e))
+  );
+  if (s.colors[e * 4 + 3] = Math.max(
+    0,
+    Math.min(255, Math.round(i / r * 255))
+  ), s.sizes[e] = et(s.covariances, e), s.dominant[e] = t.dominant[c], s.shLabels && t.shLabels && (s.shLabels[e] = t.shLabels[c]), s.shPacked && t.shPacked) {
+    const a = t.packedStride;
+    if (a === void 0) throw new Error("Static LOD packed-SH stride is unavailable.");
+    s.shPacked.set(
+      t.shPacked.subarray(c * a, (c + 1) * a),
+      e * a
+    );
+  }
+}, bt = (t, n, o) => {
+  if (o.count === t.count) {
+    for (let i = 0; i < t.count; i++)
+      g(t, n[i], o, i);
+    return;
+  }
+  const s = Math.ceil(t.count / o.count), e = mt(s, t);
+  for (let i = 0; i < o.count; i++) {
+    const c = Math.floor(i * t.count / o.count), u = Math.max(c + 1, Math.floor((i + 1) * t.count / o.count));
+    e.count = u - c;
+    for (let l = 0; l < e.count; l++)
+      g(t, n[c + l], e, l);
+    ct(e, 0, e.count, o, i);
+  }
+}, yt = (t, n) => {
+  for (let o = 0; o < n.count; o++)
+    ct(t, o * 2, Math.min(t.count, o * 2 + 2), n, o);
+};
+function Mt(t, n, o) {
+  var $;
+  if (!Number.isFinite(n) || n < 1)
+    throw new RangeError("Static LOD maxBudget must be a positive finite number.");
+  if (J(t), t.count === 0)
+    return { data: t, contentSplatCount: 0, finestSplatCount: 0, roots: new Uint32Array() };
+  const s = Math.max(1, Math.min(t.count, Math.floor(n)));
+  o == null || o({ completed: 0, total: t.count });
+  const e = dt(t.positions, t.count), i = [s];
+  for (; (i.at(-1) ?? 0) > 1; )
+    i.push(Math.ceil(i.at(-1) / 2));
+  const c = i.reduce((k, w) => k + w, 0), u = new Float32Array(c * 3), l = new Uint8Array(c * 4), p = new Float32Array(c * 6), h = new Float64Array(c), f = new Uint32Array(c), r = new Uint16Array(c), a = new Uint32Array(c), M = new Float32Array(c), b = t.sh ? new Uint32Array(c) : void 0, N = B(t), S = t.shPacked ? new Uint32Array(c * N) : void 0, v = [];
+  let F = 0;
+  const A = i.map((k) => {
+    v.push(F);
+    const w = F;
+    return F += k, {
+      count: k,
+      positions: u.subarray(w * 3, F * 3),
+      colors: l.subarray(w * 4, F * 4),
+      covariances: p.subarray(w * 6, F * 6),
+      masses: h.subarray(w, F),
+      sizes: M.subarray(w, F),
+      ...b ? { shLabels: b.subarray(w, F) } : {},
+      ...S ? {
+        shPacked: S.subarray(w * N, F * N),
+        packedStride: N
+      } : {},
+      dominant: f.subarray(w, F)
+    };
+  });
+  bt(t, e, A[0]), o == null || o({ completed: Math.floor(t.count * 0.6), total: t.count });
+  for (let k = 1; k < A.length; k++)
+    yt(A[k - 1], A[k]);
+  for (let k = 1; k < A.length; k++) {
+    const w = A[k], G = A[k - 1], Y = v[k], y = v[k - 1];
+    for (let d = 0; d < w.count; d++) {
+      const m = Math.min(2, G.count - d * 2);
+      r[Y + d] = m, a[Y + d] = y + d * 2;
+    }
+  }
+  const R = { childCount: r, childStart: a, size: M }, D = t.sh && b ? { ...t.sh, labels: b } : void 0, V = t.shPacked && S ? { ...t.shPacked, packed: S } : void 0, _ = {
+    count: c,
+    positions: u,
+    colors: l,
+    covariances: p,
+    ...D ? { sh: D } : {},
+    ...V ? { shPacked: V } : {},
+    ...t.antialias === void 0 ? {} : { antialias: t.antialias },
+    ...t.sourceFormat === void 0 ? {} : { sourceFormat: t.sourceFormat },
+    radTree: R
+  };
+  return o == null || o({ completed: t.count, total: t.count }), {
+    data: _,
+    contentSplatCount: t.count,
+    finestSplatCount: (($ = A[0]) == null ? void 0 : $.count) ?? 0,
+    roots: Uint32Array.of(c - 1)
+  };
+}
+let H, tt = new Uint32Array();
+const kt = (t) => (J(t), {
+  count: t.count,
+  positions: t.positions.slice(),
+  colors: t.colors.slice(),
+  covariances: t.covariances.slice(),
+  ...t.sh ? { sh: { ...t.sh, labels: t.sh.labels.slice() } } : {},
+  ...t.shPacked ? { shPacked: { ...t.shPacked, packed: t.shPacked.packed.slice() } } : {},
+  ...t.antialias === void 0 ? {} : { antialias: t.antialias },
+  ...t.sourceFormat === void 0 ? {} : { sourceFormat: t.sourceFormat }
+});
+function wt(t, n) {
+  try {
+    if (t.type === "build") {
+      J(t.source);
+      const e = Mt(t.source, t.maxBudget, (i) => {
+        n({ type: "progress", progress: i });
+      });
+      if (!e.data.radTree) throw new Error("Static LOD builder did not produce a hierarchy.");
+      H = e.data, tt = new Uint32Array(e.roots), n({
+        type: "built",
+        data: kt(e.data),
+        contentSplatCount: e.contentSplatCount,
+        finestSplatCount: e.finestSplatCount
+      });
+      return;
+    }
+    if (!H) throw new Error("Static LOD selection requested before build completed.");
+    const o = rt(
+      { x: t.cameraLocal[0], y: t.cameraLocal[1], z: t.cameraLocal[2] },
+      { x: t.cameraForward[0], y: t.cameraForward[1], z: t.cameraForward[2] }
+    ), s = ht(
+      /* @__PURE__ */ new Map([[0, H]]),
+      [...tt],
+      H.count,
+      o,
+      0,
+      t.budget
+    );
+    n({
+      type: "selection",
+      sequence: t.sequence,
+      indices: Uint32Array.from(s.selection.get(0) ?? [])
+    });
+  } catch (o) {
+    n({ type: "error", message: o instanceof Error ? o.message : String(o) });
+  }
+}
+const vt = (t) => {
+  const n = [
+    t.positions.buffer,
+    t.colors.buffer,
+    t.covariances.buffer
+  ];
+  return t.sh && n.push(t.sh.labels.buffer), t.shPacked && n.push(t.shPacked.packed.buffer), n;
+}, j = (t, n = []) => {
+  self.postMessage(t, n);
+};
+self.onmessage = (t) => {
+  wt(t.data, (n) => {
+    if (n.type === "built") {
+      j(n, vt(n.data));
+      return;
+    }
+    if (n.type === "selection") {
+      j(n, [n.indices.buffer]);
+      return;
+    }
+    j(n);
+  });
+};
+//# sourceMappingURL=static-lod-worker-BFIwsvQc.js.map
+`, o = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", a], { type: "text/javascript;charset=utf-8" });
+function r(n) {
+  let t;
+  try {
+    if (t = o && (self.URL || self.webkitURL).createObjectURL(o), !t) throw "";
+    const e = new Worker(t, {
+      type: "module",
+      name: n == null ? void 0 : n.name
+    });
+    return e.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(t);
+    }), e;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(a),
+      {
+        type: "module",
+        name: n == null ? void 0 : n.name
+      }
+    );
+  }
+}
+export {
+  r as default
+};
+//# sourceMappingURL=static-lod-worker-D2fyqQZO.js.map

package/dist/static-lod-worker-D2fyqQZO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-lod-worker-D2fyqQZO.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/static-lod-worker-protocol.d.ts

@@ -0,0 +1,37 @@
+import type { SplatData } from './splat-data';
+import type { StaticLodBuildProgress } from './static-lod';
+export interface StaticLodBuildRequest {
+    readonly type: 'build';
+    readonly source: SplatData;
+    readonly maxBudget: number;
+}
+export interface StaticLodSelectRequest {
+    readonly type: 'select';
+    readonly sequence: number;
+    readonly budget: number;
+    readonly cameraLocal: readonly [number, number, number];
+    readonly cameraForward: readonly [number, number, number];
+}
+export type StaticLodWorkerRequest = StaticLodBuildRequest | StaticLodSelectRequest;
+export interface StaticLodProgressResponse {
+    readonly type: 'progress';
+    readonly progress: StaticLodBuildProgress;
+}
+export interface StaticLodBuiltResponse {
+    readonly type: 'built';
+    /** Full hierarchy for a one-time GPU upload; selection later remaps active indices. */
+    readonly data: SplatData;
+    readonly contentSplatCount: number;
+    readonly finestSplatCount: number;
+}
+export interface StaticLodSelectionResponse {
+    readonly type: 'selection';
+    readonly sequence: number;
+    /** Pool indices into the resident hierarchy (not gathered splat attributes). */
+    readonly indices: Uint32Array;
+}
+export interface StaticLodErrorResponse {
+    readonly type: 'error';
+    readonly message: string;
+}
+export type StaticLodWorkerResponse = StaticLodProgressResponse | StaticLodBuiltResponse | StaticLodSelectionResponse | StaticLodErrorResponse;

package/dist/static-lod.d.ts

@@ -0,0 +1,24 @@
+import type { SplatData } from './splat-data';
+/** Progress emitted while a static scene is spatially ordered and merged. */
+export interface StaticLodBuildProgress {
+    readonly completed: number;
+    readonly total: number;
+}
+/** Result consumed by {@link StaticLodSplatMesh}. */
+export interface StaticLodBuildResult {
+    readonly data: SplatData;
+    readonly contentSplatCount: number;
+    readonly finestSplatCount: number;
+    readonly roots: Uint32Array;
+}
+/** Validates the worker-owned shape before a hierarchy copies its typed arrays. */
+export declare function validateStaticLodSource(data: SplatData): void;
+/**
+ * Builds a deterministic, coverage-preserving binary splat hierarchy.
+ *
+ * Parents use Gaussian-mixture moment matching. The finest retained level is
+ * capped before the hierarchy is materialized. The resident pool holds the
+ * full tree (~2× that ceiling: finest + parents) so camera cuts can remap
+ * active indices without rewriting splat attributes.
+ */
+export declare function buildStaticLod(source: SplatData, maxBudget: number, onProgress?: (progress: StaticLodBuildProgress) => void): StaticLodBuildResult;

package/dist/storage-attribute-mirror.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Frees the JS-heap mirror of storage buffers only the GPU ever reads.
+ *
+ * ## The gap
+ *
+ * Every `THREE.StorageBufferAttribute` is constructed around a JS typed array,
+ * and three's WebGPU backend never releases it. `WebGPUAttributeUtils`'s
+ * `createAttribute` copies the array into a `mappedAtCreation` GPU buffer,
+ * unmaps it, stores the buffer - and never calls `bufferAttribute
+ * .onUploadCallback()`, the hook that exists for exactly this and that the
+ * legacy WebGL renderer does call (`WebGLAttributes.js`). So a buffer of N
+ * slots costs N bytes on the GPU *and the same again on the JS heap,
+ * permanently*, even when nothing ever reads the CPU copy back.
+ *
+ * For VLAM that is not a rounding error. The unified work buffer alone is
+ * 72 B/slot, gathered entirely on the GPU and never read back - at a 10M-slot
+ * scene that is ~720 MB of JS heap holding zeroes, next to the ~720 MB of GPU
+ * memory doing the actual work. Add the sort scratch and it is most of a
+ * gigabyte that no on-screen number accounts for.
+ *
+ * ## Why replacing `.array` is safe
+ *
+ * Four properties of three 0.185 hold simultaneously, and this module is only
+ * correct while they all do:
+ *
+ * 1. `createAttribute` is guarded by `if (buffer === undefined)` - once the GPU
+ *    buffer exists, every later call short-circuits without reading `.array`.
+ * 2. `updateAttribute` *does* re-read `.array`, but `Attributes.update` only
+ *    reaches it when `data.version < attribute.version` or the attribute uses
+ *    `DynamicDrawUsage`. VLAM sets neither on the buffers released here - which
+ *    is what {@link StorageMirrorReleaser}'s drift guard verifies at runtime.
+ * 3. The vertex-layout paths read `.array.constructor` and
+ *    `.array.BYTES_PER_ELEMENT`, never the contents - and only for *geometry*
+ *    attributes, which these are not. Both survive a zero-length array of the
+ *    same constructor.
+ * 4. Device loss is terminal: `Renderer._onDeviceLost` sets a flag and every
+ *    later render/compute returns early. There is no re-upload-from-`.array`
+ *    path to break.
+ *
+ * A zero-length array rather than a detached buffer, deliberately: if a future
+ * change ever does bump `version` on a released attribute, a zero-length array
+ * degrades to a legal 0-byte `writeBuffer` (silent, and caught by the drift
+ * guard) where a detached one would throw inside the render loop.
+ *
+ * Peak memory is unchanged - the array has to exist for the upload copy. Only
+ * steady state improves, which is the number that was hurting.
+ *
+ * ## Relationship to `releaseRendererAttributes`
+ *
+ * They are complements, and compose in either order.
+ * `releaseRendererAttributes` frees the **GPU** buffer at dispose; this frees
+ * the **CPU** mirror during the first frame. If dispose somehow ran first, the
+ * upload probe simply reports "not uploaded" and the mirror is never released -
+ * fail-safe.
+ *
+ * Upstream fix: a one-line `bufferAttribute.onUploadCallback()` in
+ * `WebGPUAttributeUtils.createAttribute` would make the documented
+ * `BufferAttribute.onUpload()` contract work on WebGPU, and this module would
+ * become a shim for older three.
+ */
+import type * as THREE from 'three/webgpu';
+/**
+ * Drops the JS mirrors of storage attributes three has already uploaded.
+ *
+ * Owners construct one over the attributes they own **outright** and call
+ * {@link release} after each dispatch; it settles on the first frame and costs
+ * one WeakMap probe per pending attribute until then. Attributes the owner only
+ * borrows (a mesh's `splatIndex`/`sourceIndex` passed into a sorter) must never
+ * be handed to it - the same ownership line `releaseRendererAttributes` draws.
+ *
+ * Only pass attributes that are written from the CPU *at most once*, at
+ * construction. Anything the CPU rewrites per frame will silently stop
+ * uploading; the drift guard turns that into a warning rather than a mystery.
+ */
+export declare class StorageMirrorReleaser {
+    private readonly pending;
+    /** Released attributes and the `version` they carried when released. */
+    private readonly released;
+    private releasedBytesValue;
+    private warnedDrift;
+    constructor(attributes: readonly THREE.BufferAttribute[]);
+    /** Nothing left to release. */
+    get settled(): boolean;
+    /** Bytes still mirrored on the JS heap. */
+    get pendingBytes(): number;
+    /** Bytes freed so far. Diagnostic. */
+    get releasedBytes(): number;
+    /**
+     * Releases every pending mirror three has uploaded, and checks the ones
+     * already released for version drift. Idempotent and cheap once settled.
+     *
+     * @returns Bytes freed by this call.
+     */
+    release(renderer: THREE.WebGPURenderer): number;
+    /**
+     * A released attribute whose `version` moved means someone added a CPU write
+     * to a buffer this class promised was GPU-only. Three would then upload the
+     * zero-length array - a legal no-op - and the data would simply never reach
+     * the GPU. Warn once, so that failure is visible rather than a silent wrong
+     * render.
+     */
+    private checkDrift;
+}