@voluma/vlam 0.2.4 → 0.3.2

package/dist/static-lod/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `@voluma/vlam/static-lod` - worker-built merged hierarchy for a fully
+ * decoded capture.
+ *
+ * {@link StaticLodSplatMesh.load} fetches through `@voluma/vlam/loaders` and
+ * then builds the hierarchy off the main thread. Import this entry rather
+ * than calling a streaming alias: there is none.
+ *
+ * @module static-lod
+ */
+export { StaticLodSplatMesh, type StaticLodSplatMeshOptions, type StaticLodSplatMeshLoadOptions, type StaticLodLoadProgress, } from './static-lod-splat-mesh';
+export type { StaticLodBuildProgress } from './static-lod';

package/dist/{static-lod-splat-mesh.d.ts → static-lod/static-lod-splat-mesh.d.ts}

@@ -1,7 +1,7 @@
 /** @role Bridge - Camera-aware rendering for worker-built static splat hierarchies. */
 import * as THREE from 'three/webgpu';
-import { type SplatLoadOptions } from './load-scene';
-import { SplatMesh, type SplatMeshOptions, type SplatUpdateOptions } from './splat-mesh';
+import { type SplatDataLoadOptions } from '../loaders/load-splat-data';
+import { SplatMesh, type SplatMeshOptions, type SplatUpdateOptions } from '../core/splat-mesh';
 import type { StaticLodBuildProgress } from './static-lod';
 export interface StaticLodSplatMeshOptions extends SplatMeshOptions {
     /** Initial selected-frontier budget. Defaults to the build ceiling. */
@@ -18,7 +18,7 @@ export interface StaticLodLoadProgress {
     readonly completed: number;
     readonly total: number;
 }
-export interface StaticLodSplatMeshLoadOptions extends StaticLodSplatMeshOptions, SplatLoadOptions {
+export interface StaticLodSplatMeshLoadOptions extends StaticLodSplatMeshOptions, SplatDataLoadOptions {
 }
 /**
  * Static splat mesh backed by a merged hierarchy and camera-aware frontier.

package/dist/{static-lod-worker-protocol.d.ts → static-lod/static-lod-worker-protocol.d.ts}

@@ -1,4 +1,4 @@
-import type { SplatData } from './splat-data';
+import type { SplatData } from '../core/splat-data';
 import type { StaticLodBuildProgress } from './static-lod';
 export interface StaticLodBuildRequest {
     readonly type: 'build';

package/dist/{static-lod.d.ts → static-lod/static-lod.d.ts}

@@ -1,4 +1,4 @@
-import type { SplatData } from './splat-data';
+import type { SplatData } from '../core/splat-data';
 /** Progress emitted while a static scene is spatially ordered and merged. */
 export interface StaticLodBuildProgress {
     readonly completed: number;

package/dist/{static-lod-worker-D2fyqQZO.js → static-lod-worker-DktKnJkR.js}

@@ -18,14 +18,14 @@ function rt(t, n, o = lt) {
   };
 }
 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) => {
+  const c = /* @__PURE__ */ new Map(), d = /* @__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 u = Math.floor(y / o), m = t.get(u);
+    return !m || !m.radTree ? null : { data: m, local: y - u * o };
+  }, D = (y, u) => {
     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;
+    m || (m = [], c.set(y, m)), m.push(u);
+  }, V = (y, u) => {
+    const m = y.positions, P = u * 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[u] / x;
     if (!N) return U;
     const I = E * a + C * M + O * b;
     if (I <= 0) return U * A;
@@ -41,19 +41,19 @@ function ht(t, n, o, s, e, i = Number.POSITIVE_INFINITY) {
   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)), _++);
+    const u = R(y);
+    u && ($.add(y), l.push(y, V(u.data, u.local)), _++);
   }
   let k = !1;
   for (; l.size > 0; ) {
     const y = l.peekPriority();
     if (y <= e) break;
-    const d = l.peek(), m = R(d);
+    const u = l.peek(), m = R(u);
     if (!m) {
       l.pop(), _--;
       continue;
     }
-    const P = Math.floor(d / o), E = m.data.radTree, C = E.childCount[m.local];
+    const P = Math.floor(u / o), E = m.data.radTree, C = E.childCount[m.local];
     if (C === 0) {
       l.pop(), D(P, m.local);
       continue;
@@ -67,7 +67,7 @@ function ht(t, n, o, s, e, i = Number.POSITIVE_INFINITY) {
     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));
+      t.has(L) || (T = !1, y > (d.get(L) ?? 0) && d.set(L, y));
     if (!T) {
       D(P, m.local);
       continue;
@@ -80,9 +80,9 @@ function ht(t, n, o, s, e, i = Number.POSITIVE_INFINITY) {
   }
   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;
+    const y = l.pop(), u = Math.floor(y / o), m = y - u * o;
+    if (D(u, m), !w) {
+      const P = t.get(u), 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;
@@ -94,9 +94,9 @@ function ht(t, n, o, s, e, i = Number.POSITIVE_INFINITY) {
   }
   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 };
+  for (const [y, u] of c)
+    G.set(y, Uint32Array.from(u)), Y += u.length;
+  return { selection: G, count: Y, touched: d, budgetClamped: k, refinable: w };
 }
 class ft {
   constructor() {
@@ -129,13 +129,13 @@ class ft {
     if (n.length > 0) {
       n[0] = e, o[0] = i;
       const c = n.length;
-      let u = 0;
+      let d = 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;
+        const l = 2 * d + 1, p = l + 1;
+        let h = d;
+        if (l < c && o[l] > o[h] && (h = l), p < c && o[p] > o[h] && (h = p), h === d) break;
+        const f = n[d], r = o[d];
+        n[d] = n[h], o[d] = o[h], n[h] = f, o[h] = r, d = h;
       }
     }
     return s;
@@ -145,8 +145,8 @@ 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);
+  const o = n * 6, s = t[o], e = t[o + 1], i = t[o + 2], c = t[o + 3], d = t[o + 4], l = t[o + 5];
+  return s * (c * l - d * d) - e * (e * l - d * i) + i * (e * d - 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);
@@ -156,7 +156,7 @@ const ot = 10, z = 1 << ot, q = 1e-18, st = (t, n) => {
 }, 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) => {
+}, dt = (t, n, o) => (W(t) | W(n) << 1 | W(o) << 2) >>> 0, ut = (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;
@@ -165,7 +165,7 @@ const ot = 10, z = 1 << ot, q = 1e-18, st = (t, n) => {
       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);
+  let e = new Uint32Array(n), i = new Uint32Array(n), c = new Uint32Array(n), d = new Uint32Array(n);
   const l = o.map(
     (p, h) => (z - 1) / Math.max(1e-12, s[h] - p)
   );
@@ -189,7 +189,7 @@ const ot = 10, z = 1 << ot, q = 1e-18, st = (t, n) => {
         Math.floor((t[h + 2] - o[2]) * l[2])
       )
     );
-    e[p] = p, c[p] = ut(f, r, a);
+    e[p] = p, c[p] = dt(f, r, a);
   }
   for (let p = 0; p < 30; p += ot) {
     const h = new Uint32Array(z);
@@ -204,9 +204,9 @@ const ot = 10, z = 1 << ot, q = 1e-18, st = (t, n) => {
     }
     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];
+      h[M] = b + 1, d[b] = a, i[b] = e[r];
     }
-    [c, u] = [u, c], [e, i] = [i, e];
+    [c, d] = [d, c], [e, i] = [i, e];
   }
   return e;
 };
@@ -261,11 +261,11 @@ const B = (t) => t.shPacked ? nt(t.shPacked.bands) : 0, mt = (t, n) => ({
     );
   }
 }, ct = (t, n, o, s, e) => {
-  let i = 0, c = n, u = -1;
+  let i = 0, c = n, d = -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);
+    i += M, M > d && (d = 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;
   }
@@ -305,8 +305,8 @@ const B = (t) => t.shPacked ? nt(t.shPacked.bands) : 0, mt = (t, n) => ({
   }
   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;
+    const c = Math.floor(i * t.count / o.count), d = Math.max(c + 1, Math.floor((i + 1) * t.count / o.count));
+    e.count = d - c;
     for (let l = 0; l < e.count; l++)
       g(t, n[c + l], e, l);
     ct(e, 0, e.count, o, i);
@@ -323,17 +323,17 @@ function Mt(t, n, o) {
     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];
+  const e = ut(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 = [];
+  const c = i.reduce((k, w) => k + w, 0), d = 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),
+      positions: d.subarray(w * 3, F * 3),
       colors: l.subarray(w * 4, F * 4),
       covariances: p.subarray(w * 6, F * 6),
       masses: h.subarray(w, F),
@@ -351,20 +351,20 @@ function Mt(t, n, o) {
     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;
+    for (let u = 0; u < w.count; u++) {
+      const m = Math.min(2, G.count - u * 2);
+      r[Y + u] = m, a[Y + u] = y + u * 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,
+    positions: d,
     colors: l,
     covariances: p,
     ...D ? { sh: D } : {},
     ...V ? { shPacked: V } : {},
     ...t.antialias === void 0 ? {} : { antialias: t.antialias },
-    ...t.sourceFormat === void 0 ? {} : { sourceFormat: t.sourceFormat },
+    ...t.format === void 0 ? {} : { format: t.format },
     radTree: R
   };
   return o == null || o({ completed: t.count, total: t.count }), {
@@ -383,7 +383,7 @@ const kt = (t) => (J(t), {
   ...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 }
+  ...t.format === void 0 ? {} : { format: t.format }
 });
 function wt(t, n) {
   try {
@@ -445,7 +445,7 @@ self.onmessage = (t) => {
     j(n);
   });
 };
-//# sourceMappingURL=static-lod-worker-BFIwsvQc.js.map
+//# sourceMappingURL=static-lod-worker-CjrXUR8x.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;
@@ -471,4 +471,4 @@ function r(n) {
 export {
   r as default
 };
-//# sourceMappingURL=static-lod-worker-D2fyqQZO.js.map
+//# sourceMappingURL=static-lod-worker-DktKnJkR.js.map

package/dist/{static-lod-worker-D2fyqQZO.js.map → static-lod-worker-DktKnJkR.js.map}

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

package/dist/static-lod.js

@@ -0,0 +1,148 @@
+var S = Object.defineProperty;
+var V = (s, r, e) => r in s ? S(s, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[r] = e;
+var i = (s, r, e) => V(s, typeof r != "symbol" ? r + "" : r, e);
+import * as g from "three/webgpu";
+import { loadSplatData as L } from "./loaders.js";
+import { S as P } from "./splat-mesh-CsLOQb08.js";
+const b = 4096, A = 250, x = (s) => {
+  const r = [
+    s.positions.buffer,
+    s.colors.buffer,
+    s.covariances.buffer
+  ];
+  return s.sh && r.push(s.sh.labels.buffer), s.shPacked && r.push(s.shPacked.packed.buffer), r;
+}, w = (s, r) => {
+  if (!Number.isFinite(s) || s <= 0)
+    throw new RangeError("StaticLodSplatMesh budget must be a positive finite number.");
+  const e = Math.min(r, Math.floor(s));
+  return e === r || e < b ? Math.max(1, e) : Math.max(
+    b,
+    Math.floor(e / b) * b
+  );
+}, E = async (s, r, e) => {
+  const n = (await import("./static-lod-worker-DktKnJkR.js")).default, o = new n();
+  return await new Promise((c, d) => {
+    const a = () => {
+      o.terminate(), d(new DOMException("Static LOD build aborted.", "AbortError"));
+    };
+    if (e != null && e.aborted) {
+      a();
+      return;
+    }
+    e == null || e.addEventListener("abort", a, { once: !0 }), o.onerror = (l) => {
+      e == null || e.removeEventListener("abort", a), o.terminate(), d(new Error(l.message));
+    }, o.onmessage = (l) => {
+      var f, m;
+      const u = l.data;
+      if (u.type === "progress") {
+        (f = r.onLodProgress) == null || f.call(r, u.progress), (m = r.onAutoLodProgress) == null || m.call(r, { phase: "lod-build", ...u.progress });
+        return;
+      }
+      if (u.type === "error") {
+        e == null || e.removeEventListener("abort", a), o.terminate(), d(new Error(u.message));
+        return;
+      }
+      u.type === "built" && (e == null || e.removeEventListener("abort", a), c({
+        data: u.data,
+        contentSplatCount: u.contentSplatCount,
+        finestSplatCount: u.finestSplatCount,
+        worker: o
+      }));
+    };
+    const h = {
+      type: "build",
+      source: s,
+      maxBudget: r.maxBudget
+    };
+    o.postMessage(h, x(s));
+  });
+};
+class p extends P {
+  constructor(e, t, n, o, c) {
+    super(e, c);
+    i(this, "worker");
+    i(this, "ceilingValue");
+    i(this, "contentCountValue");
+    i(this, "budgetValue");
+    i(this, "sequence", 0);
+    i(this, "lastScheduleAt", -1 / 0);
+    i(this, "selectionPending", !1);
+    i(this, "cameraLocal", new g.Vector3());
+    i(this, "cameraForward", new g.Vector3(0, 0, -1));
+    i(this, "inverseWorld", new g.Matrix4());
+    this.worker = o, this.ceilingValue = n, this.contentCountValue = t, this.budgetValue = w(c.budget ?? this.ceilingValue, this.ceilingValue), this.replaceActivePrefix(this.ceilingValue), this.worker.onmessage = (d) => {
+      const a = d.data;
+      if (a.type === "error") {
+        this.selectionPending = !1;
+        return;
+      }
+      a.type !== "selection" || a.sequence !== this.sequence || (this.selectionPending = !1, this.replaceActiveIndices(a.indices));
+    }, this.budgetValue < this.ceilingValue && this.scheduleSelection(!0);
+  }
+  /** Loads, decodes and builds a merged static hierarchy without blocking UI. */
+  static async load(e, t) {
+    var d, a;
+    let n = !1;
+    const o = await L(e, {
+      ...t,
+      onProgress: (h, l) => {
+        var u, f, m;
+        (u = t.onProgress) == null || u.call(t, h, l), (f = t.onAutoLodProgress) == null || f.call(t, { phase: "download", completed: h, total: l }), !n && l > 0 && h >= l && (n = !0, (m = t.onAutoLodProgress) == null || m.call(t, { phase: "decode", completed: 0, total: 1 }));
+      }
+    });
+    n || (d = t.onAutoLodProgress) == null || d.call(t, { phase: "decode", completed: 0, total: 1 }), (a = t.onAutoLodProgress) == null || a.call(t, { phase: "decode", completed: 1, total: 1 });
+    const c = await E(o, t, t.signal);
+    return new p(
+      c.data,
+      c.contentSplatCount,
+      c.finestSplatCount,
+      c.worker,
+      t
+    );
+  }
+  get budget() {
+    return this.budgetValue;
+  }
+  get budgetCeiling() {
+    return this.ceilingValue;
+  }
+  get maxBudget() {
+    return this.ceilingValue;
+  }
+  get contentSplatCount() {
+    return this.contentCountValue;
+  }
+  /** Changes the selected frontier budget within the immutable build ceiling. */
+  setBudget(e) {
+    const t = w(e, this.ceilingValue);
+    return t === this.budgetValue || (this.budgetValue = t, this.selectionPending = !1, this.scheduleSelection(!0)), t;
+  }
+  update(e, t, n = {}) {
+    super.update(e, t, n), this.updateLod(e);
+  }
+  /** Schedules a camera-aware cut when a unified renderer owns drawing/sorting. */
+  updateLod(e) {
+    e.updateMatrixWorld(), this.updateWorldMatrix(!0, !1), this.inverseWorld.copy(this.matrixWorld).invert(), this.cameraLocal.setFromMatrixPosition(e.matrixWorld).applyMatrix4(this.inverseWorld), e.getWorldDirection(this.cameraForward).transformDirection(this.inverseWorld), this.scheduleSelection(!1);
+  }
+  dispose() {
+    this.disposed || (this.worker.terminate(), super.dispose());
+  }
+  scheduleSelection(e) {
+    if (this.disposed || this.selectionPending) return;
+    const t = performance.now();
+    if (!e && t - this.lastScheduleAt < A) return;
+    this.lastScheduleAt = t, this.selectionPending = !0;
+    const n = {
+      type: "select",
+      sequence: ++this.sequence,
+      budget: this.budgetValue,
+      cameraLocal: this.cameraLocal.toArray(),
+      cameraForward: this.cameraForward.toArray()
+    };
+    this.worker.postMessage(n);
+  }
+}
+export {
+  p as StaticLodSplatMesh
+};
+//# sourceMappingURL=static-lod.js.map

package/dist/static-lod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-lod.js","sources":["../src/lib/static-lod/static-lod-splat-mesh.ts"],"sourcesContent":["/** @role Bridge - Camera-aware rendering for worker-built static splat hierarchies. */\nimport * as THREE from 'three/webgpu';\nimport { loadSplatData, type SplatDataLoadOptions } from '../loaders/load-splat-data';\nimport type { SplatData } from '../core/splat-data';\nimport { SplatMesh, type SplatMeshOptions, type SplatUpdateOptions } from '../core/splat-mesh';\nimport type { StaticLodBuildProgress } from './static-lod';\nimport type { StaticLodWorkerRequest, StaticLodWorkerResponse } from './static-lod-worker-protocol';\n\nconst BUDGET_GRANULARITY = 4096;\nconst CAMERA_RESCHEDULE_INTERVAL_MS = 250;\n\nexport interface StaticLodSplatMeshOptions extends SplatMeshOptions {\n  /** Initial selected-frontier budget. Defaults to the build ceiling. */\n  budget?: number;\n  /** Finest frontier retained by the hierarchy and immutable pool ceiling. */\n  maxBudget: number;\n  /** Reports the spatial ordering and hierarchy-build phase. */\n  onLodProgress?: (progress: StaticLodBuildProgress) => void;\n  /** Phase-aware progress spanning download, decode completion and LOD build. */\n  onAutoLodProgress?: (progress: StaticLodLoadProgress) => void;\n}\n\nexport interface StaticLodLoadProgress {\n  readonly phase: 'download' | 'decode' | 'lod-build';\n  readonly completed: number;\n  readonly total: number;\n}\n\nexport interface StaticLodSplatMeshLoadOptions\n  extends StaticLodSplatMeshOptions, SplatDataLoadOptions {}\n\nconst transferablesFor = (data: SplatData): Transferable[] => {\n  const transferables: Transferable[] = [\n    data.positions.buffer as ArrayBuffer,\n    data.colors.buffer as ArrayBuffer,\n    data.covariances.buffer as ArrayBuffer,\n  ];\n  if (data.sh) transferables.push(data.sh.labels.buffer as ArrayBuffer);\n  if (data.shPacked) transferables.push(data.shPacked.packed.buffer as ArrayBuffer);\n  return transferables;\n};\n\nconst normalizeBudget = (value: number, ceiling: number): number => {\n  if (!Number.isFinite(value) || value <= 0) {\n    throw new RangeError('StaticLodSplatMesh budget must be a positive finite number.');\n  }\n  const clamped = Math.min(ceiling, Math.floor(value));\n  if (clamped === ceiling || clamped < BUDGET_GRANULARITY) return Math.max(1, clamped);\n  return Math.max(\n    BUDGET_GRANULARITY,\n    Math.floor(clamped / BUDGET_GRANULARITY) * BUDGET_GRANULARITY,\n  );\n};\n\nconst buildInWorker = async (\n  source: SplatData,\n  options: StaticLodSplatMeshOptions,\n  signal: AbortSignal | undefined,\n): Promise<{\n  data: SplatData;\n  contentSplatCount: number;\n  finestSplatCount: number;\n  worker: Worker;\n}> => {\n  const module = await import('./static-lod-worker?worker&inline');\n  const WorkerClass = module.default;\n  const worker = new WorkerClass();\n  return await new Promise((resolve, reject) => {\n    const abort = (): void => {\n      worker.terminate();\n      reject(new DOMException('Static LOD build aborted.', 'AbortError'));\n    };\n    if (signal?.aborted) {\n      abort();\n      return;\n    }\n    signal?.addEventListener('abort', abort, { once: true });\n    worker.onerror = (event): void => {\n      signal?.removeEventListener('abort', abort);\n      worker.terminate();\n      reject(new Error(event.message));\n    };\n    worker.onmessage = (event: MessageEvent<StaticLodWorkerResponse>): void => {\n      const response = event.data;\n      if (response.type === 'progress') {\n        options.onLodProgress?.(response.progress);\n        options.onAutoLodProgress?.({ phase: 'lod-build', ...response.progress });\n        return;\n      }\n      if (response.type === 'error') {\n        signal?.removeEventListener('abort', abort);\n        worker.terminate();\n        reject(new Error(response.message));\n        return;\n      }\n      if (response.type !== 'built') return;\n      signal?.removeEventListener('abort', abort);\n      resolve({\n        data: response.data,\n        contentSplatCount: response.contentSplatCount,\n        finestSplatCount: response.finestSplatCount,\n        worker,\n      });\n    };\n    const request: StaticLodWorkerRequest = {\n      type: 'build',\n      source,\n      maxBudget: options.maxBudget,\n    };\n    worker.postMessage(request, transferablesFor(source));\n  });\n};\n\n/**\n * Static splat mesh backed by a merged hierarchy and camera-aware frontier.\n * The full hierarchy is uploaded once; camera/budget cuts only remap the\n * active pool indices and never rewrite resident splat attributes.\n */\nexport class StaticLodSplatMesh extends SplatMesh {\n  private readonly worker: Worker;\n  private readonly ceilingValue: number;\n  private readonly contentCountValue: number;\n  private budgetValue: number;\n  private sequence = 0;\n  private lastScheduleAt = -Infinity;\n  private selectionPending = false;\n  private readonly cameraLocal = new THREE.Vector3();\n  private readonly cameraForward = new THREE.Vector3(0, 0, -1);\n  private readonly inverseWorld = new THREE.Matrix4();\n\n  private constructor(\n    data: SplatData,\n    contentSplatCount: number,\n    finestSplatCount: number,\n    worker: Worker,\n    options: StaticLodSplatMeshOptions,\n  ) {\n    super(data, options);\n    this.worker = worker;\n    this.ceilingValue = finestSplatCount;\n    this.contentCountValue = contentSplatCount;\n    this.budgetValue = normalizeBudget(options.budget ?? this.ceilingValue, this.ceilingValue);\n    // Hierarchy layout: finest level occupies pool indices `[0, finest)`.\n    this.replaceActivePrefix(this.ceilingValue);\n    this.worker.onmessage = (event: MessageEvent<StaticLodWorkerResponse>): void => {\n      const response = event.data;\n      if (response.type === 'error') {\n        this.selectionPending = false;\n        return;\n      }\n      if (response.type !== 'selection' || response.sequence !== this.sequence) return;\n      this.selectionPending = false;\n      this.replaceActiveIndices(response.indices);\n    };\n    if (this.budgetValue < this.ceilingValue) this.scheduleSelection(true);\n  }\n\n  /** Loads, decodes and builds a merged static hierarchy without blocking UI. */\n  static async load(\n    input: string | URL,\n    options: StaticLodSplatMeshLoadOptions,\n  ): Promise<StaticLodSplatMesh> {\n    let decodeReported = false;\n    const source = await loadSplatData(input, {\n      ...options,\n      onProgress: (completed, total) => {\n        options.onProgress?.(completed, total);\n        options.onAutoLodProgress?.({ phase: 'download', completed, total });\n        if (!decodeReported && total > 0 && completed >= total) {\n          decodeReported = true;\n          options.onAutoLodProgress?.({ phase: 'decode', completed: 0, total: 1 });\n        }\n      },\n    });\n    if (!decodeReported) {\n      options.onAutoLodProgress?.({ phase: 'decode', completed: 0, total: 1 });\n    }\n    options.onAutoLodProgress?.({ phase: 'decode', completed: 1, total: 1 });\n    const result = await buildInWorker(source, options, options.signal);\n    return new StaticLodSplatMesh(\n      result.data,\n      result.contentSplatCount,\n      result.finestSplatCount,\n      result.worker,\n      options,\n    );\n  }\n\n  get budget(): number {\n    return this.budgetValue;\n  }\n\n  get budgetCeiling(): number {\n    return this.ceilingValue;\n  }\n\n  get maxBudget(): number {\n    return this.ceilingValue;\n  }\n\n  get contentSplatCount(): number {\n    return this.contentCountValue;\n  }\n\n  /** Changes the selected frontier budget within the immutable build ceiling. */\n  setBudget(value: number): number {\n    const next = normalizeBudget(value, this.ceilingValue);\n    if (next === this.budgetValue) return next;\n    this.budgetValue = next;\n    this.selectionPending = false;\n    this.scheduleSelection(true);\n    return next;\n  }\n\n  override update(\n    camera: THREE.PerspectiveCamera,\n    renderer: THREE.WebGPURenderer,\n    options: SplatUpdateOptions = {},\n  ): void {\n    super.update(camera, renderer, options);\n    this.updateLod(camera);\n  }\n\n  /** Schedules a camera-aware cut when a unified renderer owns drawing/sorting. */\n  updateLod(camera: THREE.PerspectiveCamera): void {\n    camera.updateMatrixWorld();\n    this.updateWorldMatrix(true, false);\n    this.inverseWorld.copy(this.matrixWorld).invert();\n    this.cameraLocal.setFromMatrixPosition(camera.matrixWorld).applyMatrix4(this.inverseWorld);\n    camera.getWorldDirection(this.cameraForward).transformDirection(this.inverseWorld);\n    this.scheduleSelection(false);\n  }\n\n  override dispose(): void {\n    if (this.disposed) return;\n    this.worker.terminate();\n    super.dispose();\n  }\n\n  private scheduleSelection(immediate: boolean): void {\n    if (this.disposed || this.selectionPending) return;\n    const now = performance.now();\n    if (!immediate && now - this.lastScheduleAt < CAMERA_RESCHEDULE_INTERVAL_MS) return;\n    this.lastScheduleAt = now;\n    this.selectionPending = true;\n    const request: StaticLodWorkerRequest = {\n      type: 'select',\n      sequence: ++this.sequence,\n      budget: this.budgetValue,\n      cameraLocal: this.cameraLocal.toArray(),\n      cameraForward: this.cameraForward.toArray(),\n    };\n    this.worker.postMessage(request);\n  }\n}\n"],"names":["BUDGET_GRANULARITY","CAMERA_RESCHEDULE_INTERVAL_MS","transferablesFor","data","transferables","normalizeBudget","value","ceiling","clamped","buildInWorker","source","options","signal","WorkerClass","worker","resolve","reject","abort","event","response","_a","_b","request","StaticLodSplatMesh","SplatMesh","contentSplatCount","finestSplatCount","__publicField","THREE","input","decodeReported","loadSplatData","completed","total","_c","result","next","camera","renderer","immediate","now"],"mappings":"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"}

package/dist/{budget-governor.d.ts → streaming/budget-governor.d.ts}

@@ -2,10 +2,10 @@
  * Shared splat-budget governance across multiple streamed meshes.
  *
  * A single `StreamedSplatMesh` keeps itself within a per-device budget, but a
- * host that shows several streamed scenes at once (a main capture plus marker
+ * host that shows several streamed scenes at once (a main capture plus additional
  * or inset meshes) must not let each mesh claim the whole device budget -
  * their pools are separate, so the costs add. Historically hosts hand-tuned
- * this ("shrink the main mesh to 0.7 when markers exist"); the
+ * this ("shrink the main mesh to 0.7 when additional meshes exist"); the
  * {@link BudgetGovernor} makes it a first-class policy: register each mesh
  * with a priority weight and the governor splits one total budget across the
  * members, reallocating when membership, weights, or the total change.
@@ -50,7 +50,7 @@ export interface BudgetGovernorOptions {
     /**
      * Grow dead-band as a fraction of a member's current budget (default
      * `0.1`). A reallocation that would *raise* a member's budget by no more
-     * than this fraction is skipped, so brief membership churn (a marker mesh
+     * than this fraction is skipped, so brief membership churn (an additional mesh
      * appearing for a moment) does not thrash LOD schedules. Shrinks always
      * apply immediately - that is what keeps `sum(member budgets) ≤ total` an
      * invariant rather than a goal.
@@ -98,7 +98,7 @@ export declare class BudgetGovernor {
      *
      * @param member - The mesh (or compatible object) to govern.
      * @param options - `weight` (default `1`): the member's share is
-     * proportional to its weight - e.g. main mesh `7`, marker `3` reproduces
+     * proportional to its weight - e.g. main mesh `7`, additional mesh `3` reproduces
      * the old 0.7 host split. `0` registers the member suspended.
      */
     register(member: BudgetGovernedMember, options?: {

package/dist/{camera-budget-governor.d.ts → streaming/camera-budget-governor.d.ts}

@@ -2,16 +2,16 @@
  * Camera-driven splat-budget weighting across several streamed meshes.
  *
  * {@link BudgetGovernor} splits one total by *priority*, which a host must
- * choose and maintain. That is the wrong axis for a scene of markers: what
- * makes a marker worth splats is that the camera is near it, and that changes
- * every frame. Splitting a pool evenly instead (`pool / N`) gives the marker
- * you fly up to a quarter of the budget it needs while three markers nobody is
+ * choose and maintain. That is the wrong axis for a scene of additional meshes:
+ * what makes a mesh worth splats is that the camera is near it, and that changes
+ * every frame. Splitting a pool evenly instead (`pool / N`) gives the mesh
+ * you fly up to a quarter of the budget it needs while three meshes nobody is
  * looking at hold the rest.
  *
  * {@link CameraBudgetGovernor} closes that loop: each update it measures every
  * member's projected size from the camera, multiplies in the host's priority
  * tier, and writes the resulting weights to a `BudgetGovernor` in one batch.
- * Approaching one of four markers pulls budget off the far ones automatically.
+ * Approaching one of four additional meshes pulls budget off the far ones automatically.
  *
  * This is Spark's model, reached differently. Spark shares one `lodSplatCount`
  * and biases meshes with a per-mesh `lodScale` (focused 2, adjacent 0.25,
@@ -53,7 +53,7 @@ export interface CameraBudgetMember extends BudgetGovernedMember {
     /**
      * The visibility that actually decides whether the member's splats reach the
      * screen, when that differs from `visible`. `SplatMesh` provides it: a
-     * `UnifiedSplatRenderer` forces `visible = false` on every source it owns
+     * `UnifiedSplatMesh` forces `visible = false` on every source it owns
      * (only to keep the regular scene draw from double-drawing them) while the
      * source may be fully on screen through the unified draw - without this, the
      * governor would suspend every unified source and freeze its streaming.
@@ -117,8 +117,8 @@ export interface CameraBudgetMemberOptions {
     /**
      * Pins this member's weight, opting it out of camera weighting while it still
      * competes for the same total. Use it for a main scene that should hold a
-     * steady share while markers fight over the rest - e.g. `fixedWeight: 4`
-     * against markers averaging `1`.
+     * steady share while additional meshes fight over the rest - e.g. `fixedWeight: 4`
+     * against extras averaging `1`.
      */
     fixedWeight?: number;
 }
@@ -129,8 +129,8 @@ export interface CameraBudgetMemberOptions {
  * ```js
  * const governor = new CameraBudgetGovernor({ totalBudget: 4_000_000 });
  * governor.register(main, { fixedWeight: 4 }); // steady share
- * governor.register(markerA); // camera-weighted, priority 1
- * governor.register(markerB);
+ * governor.register(extraA); // camera-weighted, priority 1
+ * governor.register(extraB);
  *
  * // once per frame, after the scene graph is up to date:
  * governor.update(camera);
@@ -142,7 +142,7 @@ export interface CameraBudgetMemberOptions {
  *
  * **A member can only grow into a budget its pool can hold.** A streamed mesh
  * allocates its pool once, from its construction budget, and clamps `setBudget`
- * to it - so a marker built at a quarter of the total can never be given more
+ * to it - so a mesh built at a quarter of the total can never be given more
  * than a quarter, however close the camera gets. Construct governed meshes with
  * `maxBudget` set to the largest share they should ever reach, and price those
  * ceilings with `estimateSplatPoolBytes` first: the pools cost their ceilings

package/dist/{chunk-cache-budget.d.ts → streaming/chunk-cache-budget.d.ts}

@@ -2,9 +2,9 @@
  * Cross-mesh decoded-chunk cache arbitration.
  *
  * Every {@link StreamedSplatMesh} caps its own decoded-chunk cache, and in
- * `foveationMode: 'pagetable'` that cap is `min(2 GiB, this capture's decoded
- * size)` - a number sized for *one* streamed scene. A scene of streamed markers
- * therefore has no ceiling at all: thirteen markers plus a main are thirteen
+ * `foveationMode: 'page-table'` that cap is `min(2 GiB, this capture's decoded
+ * size)` - a number sized for *one* streamed scene. A scene of streamed additional meshes
+ * therefore has no ceiling at all: thirteen extras plus a main are thirteen
  * plus one independent caps, and because each is sized to its own capture, a
  * desktop that fits them never evicts. The background sweep then runs to
  * completion against every one of them, pulling every capture in the scene into
@@ -43,8 +43,8 @@ export interface ChunkCacheClient {
      *
      * Bytes above it are handed to siblings that can use them, the way
      * `BudgetGovernor` waterfills past a member's `maxBudget`. Without it a scene
-     * of one large capture and a dozen small markers would reserve most of the
-     * envelope for markers that cannot fill it.
+     * of one large capture and a dozen small additional meshes would reserve most of the
+     * envelope for extras that cannot fill it.
      */
     readonly ceilingBytes: number;
     /**

package/dist/{chunk-fetch-scheduler.d.ts → streaming/chunk-fetch-scheduler.d.ts}

@@ -3,7 +3,7 @@
  *
  * Every {@link StreamedSplatMesh} owns its own `ChunkLoader` worker and issues
  * chunk requests toward its own in-flight cap, so a scene of streamed meshes
- * fetches with no shared ordering: a marker the camera is pointed at competes
+ * fetches with no shared ordering: a mesh the camera is pointed at competes
  * for bandwidth and connection slots against a dozen distant ones, each of
  * which is equally entitled to its own cap. Spark does not have this problem
  * structurally - one global traversal orders every fetch want
@@ -81,7 +81,7 @@ export interface ChunkFetchSchedulerOptions {
      * Slots every registered mesh may hold regardless of weight. Default 1.
      *
      * Without a floor a scene's far meshes stop fetching entirely while the
-     * focused one streams, and a marker with no coarse coverage draws nothing -
+     * focused one streams, and a mesh with no coarse coverage draws nothing -
      * so the floor is what turns "far meshes wait" into "far meshes trickle".
      *
      * One slot is always granted regardless of this setting: a mesh entitled to
@@ -156,8 +156,8 @@ export declare class ChunkFetchScheduler {
      * asks - which is what keeps the first mesh to reschedule from taking the
      * pipe and holding it. Dividing the *remainder* after every participant's
      * floor instead would invert the whole point on a large scene: thirteen
-     * markers and a main at floor 1 consume a 16-slot pipe entirely, leaving the
-     * focused marker a smaller share than the far ones it is competing with.
+     * additional meshes and a main at floor 1 consume a 16-slot pipe entirely, leaving the
+     * focused mesh a smaller share than the far ones it is competing with.
      *
      * The denominator counts every mesh that plausibly wants the pipe - all
      * registered meshes except those both weightless and idle, plus the caller.

package/dist/{dataset-source.d.ts → streaming/dataset-source.d.ts}

@@ -1,4 +1,4 @@
-import { type SplatRequestOptions, type StreamedSplatFormat } from './loading';
+import { type SplatRequestOptions, type StreamedSplatFormat } from '../loaders/loading';
 /**
  * Where a streamed dataset's files come from.
  *