@voluma/vlam 0.1.0 → 0.2.0

package/dist/frontier-worker-CAnK_Cmu.js

@@ -0,0 +1,566 @@
+const o = `var ft = Object.defineProperty;
+var pt = (o, t, e) => t in o ? ft(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
+var k = (o, t, e) => pt(o, typeof t != "symbol" ? t + "" : t, e);
+class bt {
+  constructor(t, e = 65536) {
+    k(this, "capacity");
+    /** Occupied slots are \`[0, count)\`. */
+    k(this, "count", 0);
+    /** global index → slot, for the resident frontier. */
+    k(this, "slotOf", /* @__PURE__ */ new Map());
+    /** slot → global index (valid for \`[0, count)\`). */
+    k(this, "slotGlobal");
+    /** chunk file → how many of its splats are resident. Never holds a zero. */
+    k(this, "residentPerFile", /* @__PURE__ */ new Map());
+    k(this, "chunkSize");
+    /**
+     * Leftover work from a truncated {@link update}, so {@link drain} can finish
+     * it without re-diffing.
+     *
+     * Recomputing the whole desired set to deliver the next \`maxAppends\` splats is
+     * what made a cold 4 M-splat frontier take ~66 full traversals plus ~66 full
+     * O(frontier) diffs - quadratic, and minutes of "stuck at 1.3 M" on
+     * \`cest_ca.rad\`. The leftovers are already computed during the truncation, so
+     * keeping them turns the ramp into one O(maxAppends) step per frame.
+     *
+     * Newcomers stay in the order the traversal emitted them (biggest-on-screen
+     * first), so the earliest drains deliver the most visible detail.
+     */
+    k(this, "queuedNewcomers", []);
+    k(this, "queuedNewcomerIndex", 0);
+    /** Stale residents this plan deferred, in the slot order they were found. */
+    k(this, "queuedStale", []);
+    k(this, "queuedStaleIndex", 0);
+    this.capacity = t, this.chunkSize = e, this.slotGlobal = new Int32Array(t).fill(-1);
+  }
+  /** Whether a truncated plan left work {@link drain} can still deliver. */
+  get hasPendingDrain() {
+    return this.queuedNewcomerIndex < this.queuedNewcomers.length || this.queuedStaleIndex < this.queuedStale.length;
+  }
+  /** Forgets any deferred work, so the next plan re-diffs from scratch. */
+  clearQueue() {
+    this.queuedNewcomers = [], this.queuedNewcomerIndex = 0, this.queuedStale = [], this.queuedStaleIndex = 0;
+  }
+  /**
+   * Swap-removes \`global\` if resident, appending the resulting relocation to
+   * \`moves\`. Shared by {@link update}'s leaver pass and {@link drain}.
+   */
+  evictGlobal(t, e) {
+    const s = this.slotOf.get(t);
+    if (s === void 0) return;
+    this.slotOf.delete(t), this.release(t);
+    const c = this.count - 1;
+    if (s !== c) {
+      const i = this.slotGlobal[c];
+      this.slotGlobal[s] = i, this.slotOf.set(i, s), e.push({ slot: s, global: i });
+    }
+    this.slotGlobal[c] = -1, this.count = c;
+  }
+  /**
+   * Continues a truncated {@link update} - evicts the next deferred leavers and
+   * appends the next \`maxAppends\` deferred newcomers - with no diff against the
+   * resident set. Only valid while the frontier that produced the queue is still
+   * the one being asked for; any new {@link update}, {@link resize} or
+   * {@link clear} discards it.
+   */
+  drain(t) {
+    const e = this.count, s = [], c = this.queuedNewcomers.length - this.queuedNewcomerIndex, i = this.queuedStale.length - this.queuedStaleIndex, n = this.capacity - this.count, f = n + i, a = Math.max(0, c - f);
+    a > 0 && (this.queuedNewcomers.length -= a);
+    const u = Math.min(c - a, t, f), r = Math.min(
+      i,
+      Math.max(u - n, t - u)
+    );
+    for (let l = 0; l < r; l++)
+      this.evictGlobal(this.queuedStale[this.queuedStaleIndex + l], s);
+    this.queuedStaleIndex += r;
+    const d = this.count, h = new Uint32Array(u);
+    for (let l = 0; l < u; l++) {
+      const p = this.queuedNewcomers[this.queuedNewcomerIndex + l], w = d + l;
+      this.slotGlobal[w] = p, this.slotOf.set(p, w), this.retain(p), h[l] = p;
+    }
+    this.queuedNewcomerIndex += u, this.count = d + u;
+    for (let l = this.count; l < e; l++) this.slotGlobal[l] = -1;
+    const M = this.hasPendingDrain;
+    return M || this.clearQueue(), {
+      moves: s,
+      appendStart: d,
+      appends: h,
+      degenerateStart: this.count,
+      degenerateCount: Math.max(0, e - this.count),
+      count: this.count,
+      dropped: a,
+      truncated: M
+    };
+  }
+  /** Globals a truncated plan still intends to append, so the caller can keep
+   * their chunks cached - gathering an evicted one would write zeros into a slot
+   * inside the drawn prefix. */
+  pendingAppendGlobals() {
+    return this.queuedNewcomerIndex === 0 ? this.queuedNewcomers : this.queuedNewcomers.slice(this.queuedNewcomerIndex);
+  }
+  /** Records \`global\` as resident (its chunk gains a reference). */
+  retain(t) {
+    const e = Math.floor(t / this.chunkSize);
+    this.residentPerFile.set(e, (this.residentPerFile.get(e) ?? 0) + 1);
+  }
+  /** Drops \`global\` from the resident set (its chunk loses a reference). */
+  release(t) {
+    const e = Math.floor(t / this.chunkSize), s = (this.residentPerFile.get(e) ?? 0) - 1;
+    s > 0 ? this.residentPerFile.set(e, s) : this.residentPerFile.delete(e);
+  }
+  /**
+   * True while any splat from chunk \`file\` is still resident in the slab.
+   *
+   * The worker's cache eviction must consult this: protecting only the chunks
+   * the *current* frontier selects is not enough, because \`maxAppends\` leaves
+   * deferred leavers resident and drawn for another plan or two. Evicting one of
+   * their chunks makes the next {@link gatherGlobals} of that splat - a
+   * swap-remove relocation - write zeros into a slot inside the drawn prefix,
+   * which shows as dark speckle in the region being refined.
+   */
+  hasResidentIn(t) {
+    return this.residentPerFile.has(t);
+  }
+  /**
+   * Changes how many slots this pager may fill.
+   *
+   * The host grows and shrinks the storage behind these slots with the mesh's
+   * budget - a near mesh climbs, a distant one gives its pages back - so the
+   * pager has to follow. Growing keeps the resident frontier untouched;
+   * shrinking evicts the slots past the new capacity and reports them so the
+   * host can stop drawing them.
+   *
+   * @returns the slot range that was evicted, empty when growing.
+   */
+  resize(t) {
+    if (t === this.capacity) return { start: 0, count: 0 };
+    this.clearQueue();
+    const e = new Int32Array(t).fill(-1), s = Math.min(this.count, t);
+    e.set(this.slotGlobal.subarray(0, s));
+    for (let i = s; i < this.count; i++) {
+      const n = this.slotGlobal[i];
+      n >= 0 && this.slotOf.delete(n) && this.release(n);
+    }
+    const c = { start: s, count: Math.max(0, this.count - s) };
+    return this.slotGlobal = e, this.capacity = t, this.count = s, c;
+  }
+  /** Current resident frontier size. */
+  get residentCount() {
+    return this.count;
+  }
+  /** True iff \`global\` is currently resident. */
+  has(t) {
+    return this.slotOf.has(t);
+  }
+  /**
+   * Diffs \`desired\` (the new frontier, as global indices) against the resident
+   * set and returns the plan to realize it. Mutates internal state to the new
+   * frontier as if the plan were applied, so the caller must execute every
+   * returned op. \`desired\` may be any iterable; duplicates are ignored.
+   */
+  update(t, e) {
+    let s = new Set(t);
+    const c = this.count, i = [];
+    this.clearQueue();
+    let n = !1;
+    const f = (e == null ? void 0 : e.maxAppends) ?? 1 / 0;
+    if (Number.isFinite(f)) {
+      const l = [];
+      for (const S of s) this.slotOf.has(S) || l.push(S);
+      const p = [];
+      for (let S = 0; S < this.count; S++) {
+        const b = this.slotGlobal[S];
+        s.has(b) || p.push(b);
+      }
+      const w = this.capacity - this.count, F = Math.min(l.length, f, w + p.length), P = Math.min(
+        p.length,
+        Math.max(F - w, f - F)
+      );
+      if (n = F < l.length || P < p.length, n) {
+        const S = /* @__PURE__ */ new Set();
+        for (let b = P; b < p.length; b++) S.add(p[b]);
+        for (const b of s) this.slotOf.has(b) && S.add(b);
+        for (let b = 0; b < F; b++) S.add(l[b]);
+        s = S, this.queuedNewcomers = l.slice(F), this.queuedStale = p.slice(P);
+      }
+    }
+    let a = this.count, u = 0;
+    for (; u < a; ) {
+      const l = this.slotGlobal[u];
+      if (s.has(l)) {
+        u++;
+        continue;
+      }
+      if (this.slotOf.delete(l), this.release(l), a--, u < a) {
+        const p = this.slotGlobal[a];
+        this.slotGlobal[u] = p, s.has(p) && (this.slotOf.set(p, u), i.push({ slot: u, global: p }), u++);
+      }
+    }
+    const r = a, d = [];
+    for (const l of s) this.slotOf.has(l) || d.push(l);
+    const h = Math.min(d.length, this.capacity - r), M = new Uint32Array(h);
+    for (let l = 0; l < h; l++) {
+      const p = d[l], w = r + l;
+      this.slotGlobal[w] = p, this.slotOf.set(p, w), this.retain(p), M[l] = p;
+    }
+    this.count = r + h;
+    for (let l = this.count; l < c; l++) this.slotGlobal[l] = -1;
+    return {
+      moves: i,
+      appendStart: r,
+      appends: M,
+      degenerateStart: this.count,
+      degenerateCount: Math.max(0, c - this.count),
+      count: this.count,
+      dropped: d.length - h,
+      truncated: n
+    };
+  }
+  /** Resets to empty (e.g. on scene reload). */
+  clear() {
+    this.clearQueue(), this.slotOf.clear(), this.residentPerFile.clear(), this.slotGlobal.fill(-1), this.count = 0;
+  }
+}
+const mt = {
+  coneFov0: 90,
+  coneFov: 120,
+  coneFoveate: 0.4,
+  behindFoveate: 0.2
+};
+function gt(o) {
+  return o === 1 ? 3 : o === 2 ? 8 : 15;
+}
+function st(o, t, e, s) {
+  const c = t.length, i = new Float32Array(c * 3), n = new Uint8Array(c * 4), f = new Float32Array(c * 6);
+  let a = 0, u = null;
+  for (const h of o.values())
+    if (h.shPacked) {
+      a = h.shPacked.bands, u = h.shPacked.range;
+      break;
+    }
+  const r = a ? gt(a) : 0, d = a ? new Uint32Array(c * r) : null;
+  for (let h = 0; h < c; h++) {
+    const M = t[h], l = Math.floor(M / e), p = o.get(l);
+    if (!p) {
+      s && s.missing++;
+      continue;
+    }
+    const w = M - l * e, F = p.positions, P = p.colors, S = p.covariances;
+    i[h * 3] = F[w * 3], i[h * 3 + 1] = F[w * 3 + 1], i[h * 3 + 2] = F[w * 3 + 2], n[h * 4] = P[w * 4], n[h * 4 + 1] = P[w * 4 + 1], n[h * 4 + 2] = P[w * 4 + 2], n[h * 4 + 3] = P[w * 4 + 3];
+    for (let b = 0; b < 6; b++) f[h * 6 + b] = S[w * 6 + b];
+    if (d && p.shPacked && p.shPacked.bands === a) {
+      const b = p.shPacked.packed;
+      for (let L = 0; L < r; L++) d[h * r + L] = b[w * r + L];
+    }
+  }
+  return {
+    count: c,
+    positions: i,
+    colors: n,
+    covariances: f,
+    ...d && a && u ? { shPacked: { bands: a, packed: d, range: u } } : {}
+  };
+}
+function yt(o, t, e = mt) {
+  return {
+    origin: o,
+    ...t ? { forward: t } : {},
+    coneDot0: e.coneFov0 > 0 ? Math.cos(0.5 * e.coneFov0 * Math.PI / 180) : 1,
+    coneDot: e.coneFov > 0 ? Math.cos(0.5 * e.coneFov * Math.PI / 180) : 1,
+    coneFoveate: e.coneFoveate,
+    behindFoveate: e.behindFoveate
+  };
+}
+function K(o, t, e, s, c, i = Number.POSITIVE_INFINITY) {
+  const n = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), a = new wt(), u = s.origin.x, r = s.origin.y, d = s.origin.z, h = s.forward, M = (h == null ? void 0 : h.x) ?? 0, l = (h == null ? void 0 : h.y) ?? 0, p = (h == null ? void 0 : h.z) ?? 0, w = h !== void 0, { coneDot0: F, coneDot: P, coneFoveate: S, behindFoveate: b } = s, L = (g) => {
+    const y = Math.floor(g / e), m = o.get(y);
+    return !m || !m.radTree ? null : { data: m, local: g - y * e };
+  }, E = (g, y) => {
+    let m = n.get(g);
+    m || (m = [], n.set(g, m)), m.push(y);
+  }, Z = (g, y) => {
+    const m = g.positions, q = y * 3, A = m[q] - u, x = m[q + 1] - r, T = m[q + 2] - d, U = Math.sqrt(A * A + x * x + T * T) || 1e-6, O = g.radTree.size[y] / U;
+    if (!w) return O;
+    const D = A * M + x * l + T * p;
+    if (D <= 0) return O * b;
+    const C = D / U;
+    if (C >= F) return O;
+    if (C >= P) {
+      const N = (C - P) / (F - P);
+      return O * (S + (1 - S) * N);
+    }
+    return O * (b + (S - b) * (C / P));
+  };
+  let R = 0;
+  const H = /* @__PURE__ */ new Set();
+  for (const g of t) {
+    if (H.has(g)) continue;
+    const y = L(g);
+    y && (H.add(g), a.push(g, Z(y.data, y.local)), R++);
+  }
+  let J = !1;
+  for (; a.size > 0; ) {
+    const g = a.peekPriority();
+    if (g <= c) break;
+    const y = a.peek(), m = L(y);
+    if (!m) {
+      a.pop(), R--;
+      continue;
+    }
+    const q = Math.floor(y / e), A = m.data.radTree, x = A.childCount[m.local];
+    if (x === 0) {
+      a.pop(), E(q, m.local);
+      continue;
+    }
+    const T = R - 1 + x;
+    if (T > i) {
+      J = !0;
+      break;
+    }
+    a.pop();
+    const U = A.childStart[m.local], O = Math.floor(U / e), D = Math.floor((U + x - 1) / e);
+    let C = !0;
+    for (let N = O; N <= D; N++)
+      o.has(N) || (C = !1, g > (f.get(N) ?? 0) && f.set(N, g));
+    if (!C) {
+      E(q, m.local);
+      continue;
+    }
+    for (let N = 0; N < x; N++) {
+      const j = U + N, X = L(j), ot = Z(X.data, X.local);
+      ot <= c ? E(Math.floor(j / e), X.local) : a.push(j, ot);
+    }
+    R = T;
+  }
+  let Y = !1;
+  for (; a.size > 0; ) {
+    const g = a.pop(), y = Math.floor(g / e), m = g - y * e;
+    if (E(y, m), !Y) {
+      const q = o.get(y), A = q == null ? void 0 : q.radTree, x = A ? A.childCount[m] : 0;
+      if (x > 0) {
+        const T = A.childStart[m], U = Math.floor(T / e), O = Math.floor((T + x - 1) / e);
+        let D = !0;
+        for (let C = U; C <= O && D; C++)
+          o.has(C) || (D = !1);
+        D && (Y = !0);
+      }
+    }
+  }
+  const tt = /* @__PURE__ */ new Map();
+  let et = 0;
+  for (const [g, y] of n)
+    tt.set(g, Uint32Array.from(y)), et += y.length;
+  return { selection: tt, count: et, touched: f, budgetClamped: J, refinable: Y };
+}
+class wt {
+  constructor() {
+    k(this, "items", []);
+    // global indices
+    k(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(t, e) {
+    const s = this.items, c = this.prio;
+    let i = s.length;
+    for (s.push(t), c.push(e); i > 0; ) {
+      const n = i - 1 >> 1;
+      if (c[n] >= e) break;
+      s[i] = s[n], c[i] = c[n], s[n] = t, c[n] = e, i = n;
+    }
+  }
+  pop() {
+    const t = this.items, e = this.prio, s = t[0], c = t.pop(), i = e.pop();
+    if (t.length > 0) {
+      t[0] = c, e[0] = i;
+      const n = t.length;
+      let f = 0;
+      for (; ; ) {
+        const a = 2 * f + 1, u = a + 1;
+        let r = f;
+        if (a < n && e[a] > e[r] && (r = a), u < n && e[u] > e[r] && (r = u), r === f) break;
+        const d = t[f], h = e[f];
+        t[f] = t[r], e[f] = e[r], t[r] = d, e[r] = h, f = r;
+      }
+    }
+    return s;
+  }
+}
+const G = /* @__PURE__ */ new Map(), Q = /* @__PURE__ */ new Map(), dt = /* @__PURE__ */ new Set();
+let v = null, I = 65536, B = 256 * 1024 * 1024, _ = 0, V = /* @__PURE__ */ new Set(), z = Number.POSITIVE_INFINITY;
+const $ = 1.6, St = 1 / 32, vt = 0.75, Mt = 0.5, nt = 6e4;
+let W = null;
+function it(o) {
+  const t = o.cameraLocal, e = o.cameraForward;
+  return \`\${t[0]},\${t[1]},\${t[2]}|\${e[0]},\${e[1]},\${e[2]}|\${o.limit}|\${o.budget}\`;
+}
+function ct(o) {
+  const t = [
+    o.positions.buffer,
+    o.colors.buffer,
+    o.covariances.buffer
+  ];
+  return o.shPacked && t.push(o.shPacked.packed.buffer), t;
+}
+function Pt(o, t) {
+  if (o !== 0 || !t.radTree) return;
+  const { childCount: e, childStart: s } = t.radTree, c = t.count, i = new Uint8Array(c);
+  for (let n = 0; n < c; n++) {
+    const f = e[n];
+    if (f === 0) continue;
+    const a = s[n];
+    for (let u = 0; u < f; u++) {
+      const r = a + u - o * I;
+      r >= 0 && r < c && (i[r] = 1);
+    }
+  }
+  for (let n = 0; n < c; n++) i[n] === 0 && dt.add(o * I + n);
+}
+function rt() {
+  const o = [];
+  if (!v || _ <= B) return o;
+  const t = v, e = [...G.keys()].filter((s) => s !== 0 && !V.has(s) && !t.hasResidentIn(s)).sort((s, c) => c - s);
+  for (const s of e) {
+    if (_ <= B) break;
+    _ -= Q.get(s) ?? 0, G.delete(s), Q.delete(s), o.push(s);
+  }
+  return o;
+}
+function at(o, t, e, s, c) {
+  const i = new Uint32Array(t.moves.length), n = new Uint32Array(t.moves.length);
+  for (let d = 0; d < t.moves.length; d++)
+    i[d] = t.moves[d].slot, n[d] = t.moves[d].global;
+  const f = { missing: 0 }, a = st(G, n, I, f), u = st(G, t.appends, I, f), r = {
+    type: "plan",
+    seq: o,
+    moveSlots: i,
+    moves: a,
+    appendStart: t.appendStart,
+    appends: u,
+    degenerateStart: t.degenerateStart,
+    degenerateCount: t.degenerateCount,
+    touched: e,
+    residentCount: t.count,
+    gatherMissing: f.missing,
+    dropped: t.dropped,
+    evicted: c,
+    solvedLimit: s,
+    capacity: v.capacity,
+    converged: !t.truncated,
+    cacheBytes: _,
+    cacheLimitBytes: B
+  };
+  self.postMessage(r, [
+    i.buffer,
+    ...ct(a),
+    ...ct(u),
+    e.buffer,
+    c.buffer
+  ]);
+}
+let lt = new Uint32Array(0), ht = 0;
+function ut() {
+  if (v != null && v.hasPendingDrain)
+    for (const o of v.pendingAppendGlobals())
+      V.add(Math.floor(o / I));
+}
+function kt(o) {
+  if (!v) return;
+  if (it(o) === W && v.hasPendingDrain) {
+    const r = v.drain(nt);
+    ut(), at(o.seq, r, Uint32Array.from(lt), ht, Uint32Array.from(rt()));
+    return;
+  }
+  const e = [...dt].filter((r) => G.has(Math.floor(r / I))), s = yt(
+    { x: o.cameraLocal[0], y: o.cameraLocal[1], z: o.cameraLocal[2] },
+    { x: o.cameraForward[0], y: o.cameraForward[1], z: o.cameraForward[2] },
+    o
+  ), c = o.limit * St;
+  let i = Math.min(o.limit, Math.max(c, z)), n = K(G, e, I, s, i, o.budget);
+  if (n.budgetClamped && i < o.limit)
+    i = Math.min(o.limit, i * $), n = K(G, e, I, s, i, o.budget);
+  else if (!n.budgetClamped && n.refinable && i > c && n.count < o.budget * Mt) {
+    const r = Math.max(c, i / $), d = K(G, e, I, s, r, o.budget);
+    !d.budgetClamped && d.count <= o.budget && (i = r, n = d);
+  }
+  n.budgetClamped ? z = Math.min(o.limit, i * $) : n.refinable && n.count < o.budget * vt ? z = Math.max(c, i / $) : z = i, V = /* @__PURE__ */ new Set();
+  const f = [];
+  for (const [r, d] of n.selection) {
+    V.add(r);
+    const h = r * I;
+    for (let M = 0; M < d.length; M++) f.push(h + d[M]);
+  }
+  const a = v.update(f, { maxAppends: nt });
+  ut();
+  const u = Uint32Array.from(
+    [...n.touched].filter(([r]) => !G.has(r)).sort((r, d) => d[1] - r[1]).map(([r]) => r)
+  );
+  lt = u, ht = i, W = it(o), at(o.seq, a, Uint32Array.from(u), i, Uint32Array.from(rt()));
+}
+self.onmessage = (o) => {
+  var e;
+  const t = o.data;
+  if (t.type === "init") {
+    I = t.chunkSize, B = t.cpuCacheBytes, v = new bt(t.capacity, I), W = null;
+    return;
+  }
+  if (t.type === "resize") {
+    v == null || v.resize(t.capacity);
+    return;
+  }
+  if (t.type === "cacheBudget") {
+    B = t.cpuCacheBytes;
+    return;
+  }
+  if (t.type === "chunk") {
+    const s = {
+      count: t.count,
+      positions: t.positions,
+      colors: t.colors,
+      covariances: t.covariances,
+      radTree: { childCount: t.childCount, childStart: t.childStart, size: t.size },
+      ...t.shBands && t.shPacked && t.shRange ? { shPacked: { bands: t.shBands, packed: t.shPacked, range: t.shRange } } : {}
+    }, c = Q.get(t.file);
+    c !== void 0 && (_ -= c);
+    const i = t.positions.byteLength + t.colors.byteLength + t.covariances.byteLength + t.childCount.byteLength + t.childStart.byteLength + t.size.byteLength + (((e = t.shPacked) == null ? void 0 : e.byteLength) ?? 0);
+    G.set(t.file, s), Q.set(t.file, i), _ += i, Pt(t.file, s);
+    return;
+  }
+  kt(t);
+};
+//# sourceMappingURL=frontier-worker-Wc3WwHLq.js.map
+`, s = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", o], { type: "text/javascript;charset=utf-8" });
+function r(n) {
+  let e;
+  try {
+    if (e = s && (self.URL || self.webkitURL).createObjectURL(s), !e) throw "";
+    const t = new Worker(e, {
+      type: "module",
+      name: n == null ? void 0 : n.name
+    });
+    return t.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(e);
+    }), t;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(o),
+      {
+        type: "module",
+        name: n == null ? void 0 : n.name
+      }
+    );
+  }
+}
+export {
+  r as default
+};
+//# sourceMappingURL=frontier-worker-CAnK_Cmu.js.map

package/dist/frontier-worker-CAnK_Cmu.js.map

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

package/dist/half-float-Cs4FDq8Q.js

@@ -0,0 +1,30 @@
+function N(r) {
+  const o = r & 32768 ? -1 : 1, t = r >>> 10 & 31, n = r & 1023;
+  return t === 0 ? o * 2 ** -14 * (n / 1024) : t === 31 ? n === 0 ? o * (1 / 0) : Number.NaN : o * 2 ** (t - 15) * (1 + n / 1024);
+}
+function c(r) {
+  if (Number.isNaN(r)) return 32256;
+  if (!Number.isFinite(r)) return r > 0 ? 31744 : 64512;
+  s[0] = r;
+  const o = a[0], t = o >>> 16 & 32768;
+  let n = o >>> 23 & 255, e = o & 8388607;
+  if (n < 113) {
+    if (n < 103) return t;
+    e |= 8388608;
+    const f = 113 - n, u = (e >>> f + 13) + (e >>> f + 12 & 1);
+    return t | u;
+  }
+  if (n > 142) return t | 31743;
+  const i = e + 4095 + (e >>> 13 & 1);
+  return i & 8388608 ? (n += 1, n > 142 ? t | 31743 : t | n - 112 << 10) : t | n - 112 << 10 | i >>> 13;
+}
+function l(r, o, t = 0, n = r.length - t, e = 0) {
+  for (let i = 0; i < n; i++)
+    o[e + i] = c(r[t + i]);
+}
+const s = new Float32Array(1), a = new Uint32Array(s.buffer);
+export {
+  l as e,
+  N as h
+};
+//# sourceMappingURL=half-float-Cs4FDq8Q.js.map

package/dist/half-float-Cs4FDq8Q.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"half-float-Cs4FDq8Q.js","sources":["../src/lib/half-float.ts"],"sourcesContent":["/** Decodes an IEEE 754 half-precision (binary16) value to a JS number. */\nexport function halfToFloat(value: number): number {\n  const sign = value & 0x8000 ? -1 : 1;\n  const exponent = (value >>> 10) & 0x1f;\n  const fraction = value & 0x03ff;\n  if (exponent === 0) return sign * 2 ** -14 * (fraction / 1024);\n  if (exponent === 0x1f) return fraction === 0 ? sign * Infinity : Number.NaN;\n  return sign * 2 ** (exponent - 15) * (1 + fraction / 1024);\n}\n\n/**\n * Encodes a JS number as IEEE 754 half-precision (binary16) bits.\n *\n * Finite values outside ±65504 clamp to the half max; NaN → quiet NaN;\n * ±Infinity stay infinite. Used when packing float32 pool backing into\n * `rgba16float` GPU textures.\n */\nexport function floatToHalf(value: number): number {\n  if (Number.isNaN(value)) return 0x7e00;\n  if (!Number.isFinite(value)) return value > 0 ? 0x7c00 : 0xfc00;\n\n  // Reinterpret as float32 bits without a DataView allocation on the hot path.\n  _f32[0] = value;\n  const bits = _u32[0] as number;\n  const sign = (bits >>> 16) & 0x8000;\n  let exponent = (bits >>> 23) & 0xff;\n  let mantissa = bits & 0x7fffff;\n\n  // Too small for a normalized half → flush to signed zero (or denormal).\n  if (exponent < 113) {\n    if (exponent < 103) return sign;\n    // Denormal: shift the implicit 1 into the mantissa.\n    mantissa |= 0x800000;\n    const shift = 113 - exponent;\n    const denorm = (mantissa >>> (shift + 13)) + ((mantissa >>> (shift + 12)) & 1);\n    return sign | denorm;\n  }\n\n  // Overflow → clamp to ±65504 (max finite half), not infinity: pool centers\n  // and covariances that blow the half range should stay finite for sampling.\n  if (exponent > 142) return sign | 0x7bff;\n\n  // Round-to-nearest-even on the 10-bit mantissa.\n  const rounded = mantissa + 0x0fff + ((mantissa >>> 13) & 1);\n  if (rounded & 0x800000) {\n    // Mantissa overflow into the exponent.\n    exponent += 1;\n    if (exponent > 142) return sign | 0x7bff;\n    return sign | ((exponent - 112) << 10);\n  }\n  return sign | ((exponent - 112) << 10) | (rounded >>> 13);\n}\n\n/**\n * Packs `src[srcOffset..srcOffset+count)` into half bits at `dst[dstOffset..]`.\n * Lengths are in elements (floats / halfs), not bytes.\n */\nexport function encodeFloat32ToHalf(\n  src: Float32Array,\n  dst: Uint16Array,\n  srcOffset = 0,\n  count = src.length - srcOffset,\n  dstOffset = 0,\n): void {\n  for (let i = 0; i < count; i++) {\n    dst[dstOffset + i] = floatToHalf(src[srcOffset + i] as number);\n  }\n}\n\nconst _f32 = new Float32Array(1);\nconst _u32 = new Uint32Array(_f32.buffer);\n"],"names":["halfToFloat","value","sign","exponent","fraction","floatToHalf","_f32","bits","_u32","mantissa","shift","denorm","rounded","encodeFloat32ToHalf","src","dst","srcOffset","count","dstOffset"],"mappings":"AACO,SAASA,EAAYC,GAAuB;AACjD,QAAMC,IAAOD,IAAQ,QAAS,KAAK,GAC7BE,IAAYF,MAAU,KAAM,IAC5BG,IAAWH,IAAQ;AACzB,SAAIE,MAAa,IAAUD,IAAO,KAAK,OAAOE,IAAW,QACrDD,MAAa,KAAaC,MAAa,IAAIF,IAAO,UAAW,OAAO,MACjEA,IAAO,MAAMC,IAAW,OAAO,IAAIC,IAAW;AACvD;AASO,SAASC,EAAYJ,GAAuB;AACjD,MAAI,OAAO,MAAMA,CAAK,EAAG,QAAO;AAChC,MAAI,CAAC,OAAO,SAASA,CAAK,EAAG,QAAOA,IAAQ,IAAI,QAAS;AAGzD,EAAAK,EAAK,CAAC,IAAIL;AACV,QAAMM,IAAOC,EAAK,CAAC,GACbN,IAAQK,MAAS,KAAM;AAC7B,MAAIJ,IAAYI,MAAS,KAAM,KAC3BE,IAAWF,IAAO;AAGtB,MAAIJ,IAAW,KAAK;AAClB,QAAIA,IAAW,IAAK,QAAOD;AAE3B,IAAAO,KAAY;AACZ,UAAMC,IAAQ,MAAMP,GACdQ,KAAUF,MAAcC,IAAQ,OAASD,MAAcC,IAAQ,KAAO;AAC5E,WAAOR,IAAOS;AAAA,EAChB;AAIA,MAAIR,IAAW,IAAK,QAAOD,IAAO;AAGlC,QAAMU,IAAUH,IAAW,QAAWA,MAAa,KAAM;AACzD,SAAIG,IAAU,WAEZT,KAAY,GACRA,IAAW,MAAYD,IAAO,QAC3BA,IAASC,IAAW,OAAQ,MAE9BD,IAASC,IAAW,OAAQ,KAAOS,MAAY;AACxD;AAMO,SAASC,EACdC,GACAC,GACAC,IAAY,GACZC,IAAQH,EAAI,SAASE,GACrBE,IAAY,GACN;AACN,WAAS,IAAI,GAAG,IAAID,GAAO;AACzB,IAAAF,EAAIG,IAAY,CAAC,IAAIb,EAAYS,EAAIE,IAAY,CAAC,CAAW;AAEjE;AAEA,MAAMV,IAAO,IAAI,aAAa,CAAC,GACzBE,IAAO,IAAI,YAAYF,EAAK,MAAM;"}

package/dist/half-float.d.ts

@@ -0,0 +1,15 @@
+/** Decodes an IEEE 754 half-precision (binary16) value to a JS number. */
+export declare function halfToFloat(value: number): number;
+/**
+ * Encodes a JS number as IEEE 754 half-precision (binary16) bits.
+ *
+ * Finite values outside ±65504 clamp to the half max; NaN → quiet NaN;
+ * ±Infinity stay infinite. Used when packing float32 pool backing into
+ * `rgba16float` GPU textures.
+ */
+export declare function floatToHalf(value: number): number;
+/**
+ * Packs `src[srcOffset..srcOffset+count)` into half bits at `dst[dstOffset..]`.
+ * Lengths are in elements (floats / halfs), not bytes.
+ */
+export declare function encodeFloat32ToHalf(src: Float32Array, dst: Uint16Array, srcOffset?: number, count?: number, dstOffset?: number): void;

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * VLAM! | a WebGPU-first 3D Gaussian Splatting renderer for three.js.
+ *
+ * Public API surface. Everything else under `src/lib/` is internal and may
+ * change without notice.
+ *
+ * Format-specific parsers live on optional subpaths:
+ *  - `@voluma/vlam/formats/ply` - 3DGS `.ply`, raw and compressed
+ *  - `@voluma/vlam/formats/sog` - PlayCanvas SOG, bundled and unbundled
+ *  - `@voluma/vlam/formats/rad` - Spark `.rad`/`.radc`
+ *  - `@voluma/vlam/formats/lcc` - XGRIDS LCC / `.lcc2` + collision helpers
+ *  - `@voluma/vlam/formats/spz` - Niantic `.spz`
+ *  - `@voluma/vlam/formats/splat` - antimatter15 `.splat`
+ *  - `@voluma/vlam/formats/ksplat` - mkkellogg `.ksplat`
+ *
+ * {@link loadScene} / {@link StreamedSplatMesh.load} still accept those formats
+ * without importing a subpath; the library loads format code on demand.
+ *
+ * @module core
+ */
+export { SplatMesh, MAX_SH_BANDS, DEFAULT_FOVEATION_TARGET_PX, DEFAULT_FOVEATION_DRAW_BUDGET, resolveSplatPerformanceProfile, type UnifiedSourceView, type SplatMeshOptions, type SplatUpdateOptions, type SplatSortStrategy, type SplatPerformanceProfile, type SplatRange, type SplatPickOptions, type SplatPickResult, type SplatNearestResult, type SplatRayResult, type SplatHeightResult, type SplatChannelType, type SplatChannelOptions, } from './splat-mesh';
+export { SplatPool, type SplatPoolOptions } from './splat-mesh-pool';
+export { SPLAT_DATA_TEXTURE_WIDTH, deviceMaxTextureSize, assertPoolRowsFitDevice, } from './splat-mesh-pool';
+export { MAX_DOF_RADIUS_PX, MAX_DOF_VARIANCE, apertureAngleFromSize, computeDofCocVariancePx2, computeDofOpacityFade, clampDepthOfFieldSettings, type DepthOfFieldSettings, } from './depth-of-field';
+export { DEFAULT_RELIGHT_BLEND, DEFAULT_RELIGHT_BRIGHTNESS, DEFAULT_RELIGHT_BACKGROUND, DEFAULT_RELIGHT_SOFTNESS, clampRelightingSettings, createPlaceholderRelightTexture, type RelightingSettings, type RelightingUniforms, } from './relighting';
+export { type SplatOrientation, type OrientableFormat, createYUpTransform, yUpTransformForFormat, } from './orientation';
+export { StreamedSplatMesh, type StreamedSplatMeshOptions, type InitialRevealState, type PersistentChannelOptions, type StreamedSplatPerformanceEvent, } from './streamed-splat-mesh';
+export { StaticLodSplatMesh, type StaticLodSplatMeshOptions, type StaticLodSplatMeshLoadOptions, type StaticLodLoadProgress, } from './static-lod-splat-mesh';
+export type { StaticLodBuildProgress } from './static-lod';
+export { SplatScene, type SplatSceneOptions, type AddSourceOptions } from './splat-scene';
+export { MAX_SOURCES } from './source-transform';
+export type { SplatShInputs, Vec3Uniform } from './splat-mesh-material';
+export { UnifiedSplatRenderer, supportsUnifiedSplatRenderer, type UnifiedSplatPickResult, type UnifiedSplatRendererOptions, type UnifiedSplatSourceOptions, } from './unified-splat-renderer';
+export { resolveSplatBudget, detectSplatDeviceProfile, classifySplatGpuClass, probeSplatGpuClass, isFillConstrainedSplatDevice, recommendedMaxPixelRatio, recommendedRadMaxStdDev, recommendedXrFramebufferScale, resolveXrSplatBudget, resolveCpuCacheBytes, suggestAdaptivePixelRatio, estimateSplatPoolBytes, type SplatBudgetOptions, type SplatCostClass, type SplatDeviceProfile, type SplatGpuClass, type SplatGpuAdapterInfo, type AdaptivePixelRatioInput, type AdaptivePixelRatioResult, type SplatPoolBytesOptions, } from './splat-budget';
+export { xrSessionInit } from './xr-view';
+export { BudgetGovernor, type BudgetGovernorOptions, type BudgetGovernedMember, } from './budget-governor';
+export { CameraBudgetGovernor, type CameraBudgetGovernorOptions, type CameraBudgetMember, type CameraBudgetMemberOptions, } from './camera-budget-governor';
+export { createSplatRenderer, type CreateSplatRendererOptions, type SplatRendererGpu, type SplatRendererGpuAdapter, type SplatRendererGpuDevice, } from './create-splat-renderer';
+export { recommendedWebGpuRequiredLimits, supportsWebGpuPowerPreference, webGpuPowerPreferenceOptions, estimateLargestStorageBufferBytes, estimateUnifiedWorkBufferBytes, estimateUnifiedWorkBufferPeakBytes, deviceMaxStorageBufferBindingSize, assertStorageBufferFitsDevice, WORK_BUFFER_CENTERS_BYTES_PER_SPLAT, WORK_BUFFER_BYTES_PER_SLOT, WEBGPU_DEFAULT_MAX_STORAGE_BUFFER_BINDING_SIZE, type WebGpuRequiredLimits, type WebGpuPowerPreference, } from './webgpu-limits';
+export { loadScene, loadSceneFile, type SplatLoadOptions, type SplatFileLoadOptions, } from './load-scene';
+export { ChunkLoader } from './chunk-loader';
+export { ChunkFetchScheduler, type ChunkFetchSchedulerOptions, type ChunkFetchClient, type ChunkFetchHandle, type ChunkFetchKind, } from './chunk-fetch-scheduler';
+export { ChunkCacheBudget, type ChunkCacheBudgetOptions, type ChunkCacheClient, type ChunkCacheHandle, } from './chunk-cache-budget';
+export { SplatLoadError, isAbortError, type SplatProgressCallback, type SplatFormat, type SplatSourceFormat, type StreamedSplatFormat, type SplatRequestOptions, type SplatLoadPhase, type SplatInputOptions, type ChunkFileFormat, } from './loading';
+export type { CollisionMeshTile } from './formats/lcc/collision-mesh';
+export type { SceneCollision, CollisionMeshDescriptor, EnvironmentTile } from './lod-source';
+export { httpDatasetSource, createLocalDataset } from './dataset-source';
+export type { SplatDatasetSource, LocalDataset } from './dataset-source';
+export type { SplatData, SplatShData, SplatPackedShData } from './splat-data';
+export { createSelectionVolume, selectInData, countInData, type SelectionVolume, type SelectionVolumeKind, type SelectionVolumeOptions, } from './selection-volume';
+export { partitionSplatData, type SplatPartition } from './splat-partition';
+export type { SplatModifier, SplatContext, SplatOutputs, ModifierStackTarget, } from './splat-modifier';
+export { ModifierSlots } from './splat-modifier';
+export { setVlamLogHandler, type VlamLogHandler, type VlamLogLevel } from './logging';