@voluma/vlam 0.1.0 → 0.2.1

package/dist/formats/rad.js

@@ -0,0 +1,1098 @@
+var fe = Object.defineProperty;
+var le = (t, e, n) => e in t ? fe(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var l = (t, e, n) => le(t, typeof e != "symbol" ? e + "" : e, n);
+import { h as H } from "../half-float-Cs4FDq8Q.js";
+import { w as we } from "../splat-data-BZM5dhhx.js";
+import { s as D, n as ge, p as be } from "../sh-pack-D5wAe5gg.js";
+import * as R from "three/webgpu";
+import { t as j } from "../loading-wLo8vRbA.js";
+import { l as ye } from "../splat-budget-PSojLJPO.js";
+function me(t) {
+  return t.encoding === "f32" ? 4 : t.encoding === "f16" ? 2 : 1;
+}
+function z(t) {
+  if (t.min === void 0 || t.max === void 0)
+    throw new Error(`RAD "${t.property}" (${t.encoding}) is missing its min/max range.`);
+  return { min: t.min, max: t.max };
+}
+function G(t) {
+  if (t.max === void 0)
+    throw new Error(`RAD "${t.property}" (${t.encoding}) is missing its max range.`);
+  return t.max;
+}
+function A(t, e, n, s, r) {
+  if (t.byteLength < s * n * r)
+    throw new Error(
+      `RAD "${e.property}" column holds ${t.byteLength} bytes, fewer than the ${s * n * r} its declared ${s} splats need.`
+    );
+}
+function M(t, e, n, s) {
+  switch (A(t, e, n, s, me(e)), e.encoding) {
+    case "f32":
+      return Q(t, n, s);
+    case "f16":
+      return Z(t, n, s);
+    case "f32_lebytes":
+      return Ce(t, n, s);
+    case "f16_lebytes":
+      return Ae(t, n, s);
+    case "r8": {
+      const { min: r, max: o } = z(e);
+      return ve(t, n, s, r, o);
+    }
+    case "r8_delta": {
+      const { min: r, max: o } = z(e);
+      return De(t, n, s, r, o);
+    }
+    case "s8":
+      return Ee(t, n, s, G(e));
+    case "s8_delta":
+      return xe(t, n, s, G(e));
+    case "ln_0r8": {
+      const { min: r, max: o } = z(e);
+      return $e(t, n, s, r, o);
+    }
+    case "ln_f16":
+      return Fe(t, n, s);
+    default:
+      throw new Error(`Unsupported RAD "${e.property}" encoding "${e.encoding}".`);
+  }
+}
+function Re(t, e, n) {
+  if (e.encoding === "oct88r8")
+    return A(t, e, 3, n, 1), _e(t, n);
+  (e.encoding === "f32" || e.encoding === "f16") && A(t, e, 3, n, e.encoding === "f32" ? 4 : 2);
+  const s = e.encoding === "f32" ? Q(t, 3, n) : e.encoding === "f16" ? Z(t, 3, n) : void 0;
+  if (!s) throw new Error(`Unsupported RAD orientation encoding "${e.encoding}".`);
+  const r = new Float32Array(n * 4);
+  for (let o = 0; o < n; o++) {
+    const i = s[o * 3 + 0], c = s[o * 3 + 1], a = s[o * 3 + 2];
+    r[o * 4 + 0] = i, r[o * 4 + 1] = c, r[o * 4 + 2] = a, r[o * 4 + 3] = Math.sqrt(Math.max(0, 1 - i * i - c * c - a * a));
+  }
+  return r;
+}
+function Se(t, e, n) {
+  if (e.encoding !== "u16")
+    throw new Error(`Unsupported RAD child_count encoding "${e.encoding}".`);
+  return A(t, e, 1, n, 2), ee(t, n);
+}
+function ke(t, e, n) {
+  if (e.encoding !== "u32")
+    throw new Error(`Unsupported RAD child_start encoding "${e.encoding}".`);
+  return A(t, e, 1, n, 4), te(t, n);
+}
+const W = new DataView(new ArrayBuffer(4));
+function pe(t) {
+  return W.setUint32(0, t, !0), W.getFloat32(0, !0);
+}
+function Q(t, e, n) {
+  const s = new DataView(t.buffer, t.byteOffset, t.byteLength), r = new Float32Array(n * e);
+  for (let o = 0; o < n; o++) {
+    let i = o * 4;
+    for (let c = 0; c < e; c++)
+      r[o * e + c] = s.getFloat32(i, !0), i += n * 4;
+  }
+  return r;
+}
+function Z(t, e, n) {
+  const s = new DataView(t.buffer, t.byteOffset, t.byteLength), r = new Float32Array(n * e);
+  for (let o = 0; o < n; o++) {
+    let i = o * 2;
+    for (let c = 0; c < e; c++)
+      r[o * e + c] = H(s.getUint16(i, !0)), i += n * 2;
+  }
+  return r;
+}
+function Ce(t, e, n) {
+  const s = n * e, r = new Float32Array(n * e);
+  for (let o = 0; o < n; o++)
+    for (let i = 0; i < e; i++) {
+      const c = n * i + o, a = (t[c] | t[c + s] << 8 | t[c + s * 2] << 16 | t[c + s * 3] << 24) >>> 0;
+      r[o * e + i] = pe(a);
+    }
+  return r;
+}
+function Ae(t, e, n) {
+  const s = n * e, r = new Float32Array(n * e);
+  for (let o = 0; o < n; o++)
+    for (let i = 0; i < e; i++) {
+      const c = n * i + o, a = t[c] | t[c + s] << 8;
+      r[o * e + i] = H(a);
+    }
+  return r;
+}
+function ve(t, e, n, s, r) {
+  const o = new Float32Array(n * e), i = r - s;
+  for (let c = 0; c < n; c++) {
+    let a = c;
+    for (let h = 0; h < e; h++)
+      o[c * e + h] = t[a] / 255 * i + s, a += n;
+  }
+  return o;
+}
+function De(t, e, n, s, r) {
+  const o = new Float32Array(n * e), i = r - s, c = new Uint8Array(e);
+  for (let a = 0; a < n; a++) {
+    let h = a;
+    for (let u = 0; u < e; u++) {
+      const d = c[u] + t[h] & 255;
+      c[u] = d, o[a * e + u] = d / 255 * i + s, h += n;
+    }
+  }
+  return o;
+}
+function Ee(t, e, n, s) {
+  const r = new Float32Array(n * e);
+  for (let o = 0; o < n; o++) {
+    let i = o;
+    for (let c = 0; c < e; c++) {
+      const a = t[i], h = a >= 128 ? a - 256 : a;
+      r[o * e + c] = h / 127 * s, i += n;
+    }
+  }
+  return r;
+}
+function xe(t, e, n, s) {
+  const r = new Float32Array(n * e), o = new Uint8Array(e);
+  for (let i = 0; i < n; i++) {
+    let c = i;
+    for (let a = 0; a < e; a++) {
+      const h = o[a] + t[c] & 255;
+      o[a] = h;
+      const u = h >= 128 ? h - 256 : h;
+      r[i * e + a] = u / 127 * s, c += n;
+    }
+  }
+  return r;
+}
+function $e(t, e, n, s, r) {
+  const o = new Float32Array(n * e), i = (r - s) / 254;
+  for (let c = 0; c < n; c++) {
+    let a = c;
+    for (let h = 0; h < e; h++) {
+      const u = t[a];
+      o[c * e + h] = u === 0 ? 0 : Math.exp(s + (u - 1) * i), a += n;
+    }
+  }
+  return o;
+}
+function Fe(t, e, n) {
+  const s = new DataView(t.buffer, t.byteOffset, t.byteLength), r = new Float32Array(n * e);
+  for (let o = 0; o < n; o++) {
+    let i = o * 2;
+    for (let c = 0; c < e; c++)
+      r[o * e + c] = Math.exp(H(s.getUint16(i, !0))), i += n * 2;
+  }
+  return r;
+}
+function _e(t, e) {
+  const n = new Float32Array(e * 4);
+  for (let s = 0; s < e; s++) {
+    const r = s * 3, o = t[r], i = t[r + 1], c = t[r + 2];
+    let a = o / 255 * 2 - 1, h = i / 255 * 2 - 1;
+    const u = 1 - Math.abs(a) - Math.abs(h), d = Math.max(-u, 0);
+    a = a >= 0 ? a - d : a + d, h = h >= 0 ? h - d : h + d;
+    const f = Math.hypot(a, h, u) || 1, w = c / 255 * 0.5 * Math.PI, g = Math.sin(w), b = Math.cos(w);
+    n[s * 4 + 0] = a / f * g, n[s * 4 + 1] = h / f * g, n[s * 4 + 2] = u / f * g, n[s * 4 + 3] = b;
+  }
+  return n;
+}
+function ee(t, e) {
+  const n = new DataView(t.buffer, t.byteOffset, t.byteLength), s = new Uint16Array(e);
+  for (let r = 0; r < e; r++) s[r] = n.getUint16(r * 2, !0);
+  return s;
+}
+function te(t, e) {
+  const n = new DataView(t.buffer, t.byteOffset, t.byteLength), s = new Uint32Array(e);
+  for (let r = 0; r < e; r++) s[r] = n.getUint32(r * 4, !0);
+  return s;
+}
+const Me = 809779538, ne = 1128546642, U = 1 << 24;
+function oe(t, e) {
+  if (!Number.isSafeInteger(t) || t < 0)
+    throw new Error(`Invalid RAD ${e} splat count: ${t}.`);
+}
+function Ue(t, e) {
+  if (oe(t, e), t > U)
+    throw new Error(
+      `RAD ${e} declares ${t} splats, above the supported maximum of ${U}.`
+    );
+}
+async function mt(t) {
+  var h;
+  const e = new Uint8Array(t);
+  if (e.byteLength < 8) throw new Error("Truncated RAD file.");
+  if (new DataView(e.buffer, e.byteOffset, e.byteLength).getUint32(0, !0) === ne)
+    return Y([await L(e, 0)]);
+  const { meta: r, chunksStart: o } = re(t);
+  if (r.count > U)
+    throw new Error(
+      `RAD header declares ${r.count} splats, above the supported maximum of ${U} for a one-shot decode; load this file as a streamed scene instead.`
+    );
+  const i = [];
+  let c, a;
+  for (const [u, d] of r.chunks.entries()) {
+    if (d.filename !== void 0)
+      throw new Error(
+        `RAD chunk ${u} is an external .radc file ("${d.filename}"); one-shot loading only supports a single self-contained .rad file.`
+      );
+    const f = o + d.offset;
+    if (f + d.bytes > e.byteLength)
+      throw new Error(`RAD chunk ${u} extends past the file.`);
+    const w = await L(e, f, !0, c, a);
+    c ?? (c = w.shCodebook), a ?? (a = (h = w.shPacked) == null ? void 0 : h.range.max[0]), i.push(w);
+  }
+  return Y(i);
+}
+function re(t) {
+  const e = new Uint8Array(t);
+  if (e.byteLength < 8) throw new Error("Truncated RAD file.");
+  const n = new DataView(e.buffer, e.byteOffset, e.byteLength), s = n.getUint32(0, !0);
+  if (s !== Me)
+    throw new Error(`Not a RAD file (magic 0x${s.toString(16).padStart(8, "0")}).`);
+  const r = n.getUint32(4, !0);
+  if (e.byteLength < 8 + r) throw new Error("Truncated RAD header.");
+  const o = JSON.parse(ie(e, 8, r));
+  if (o.version !== 1) throw new Error(`Unsupported RAD version ${o.version}.`);
+  if (o.type !== "gsplat") throw new Error(`Unsupported RAD type "${o.type}".`);
+  if (oe(o.count, "header"), !Array.isArray(o.chunks)) throw new Error("RAD header is missing its chunk list.");
+  const i = o.chunks;
+  for (const [c, a] of i.entries())
+    if (!Number.isSafeInteger(a == null ? void 0 : a.offset) || a.offset < 0 || !Number.isSafeInteger(a == null ? void 0 : a.bytes) || a.bytes < 0)
+      throw new Error(`RAD chunk ${c} declares an invalid byte range.`);
+  if (o.chunkSize !== void 0) {
+    if (!Number.isSafeInteger(o.chunkSize) || o.chunkSize <= 0 || o.chunkSize > U)
+      throw new Error(`Invalid RAD chunk size: ${o.chunkSize}.`);
+    if (o.count > o.chunkSize * i.length)
+      throw new Error(
+        `RAD header declares ${o.count} splats, more than its ${i.length} chunks of ${o.chunkSize} can hold.`
+      );
+  }
+  return { meta: o, chunksStart: 8 + se(r) };
+}
+async function Be(t, e, n, s = !0) {
+  const r = await L(new Uint8Array(t), 0, !0, e, n);
+  return Pe(r, s);
+}
+function Pe(t, e) {
+  const { count: n } = t, s = new Float32Array(n * 3), r = new Uint8Array(n * 4), o = new Float32Array(n * 6);
+  if (!t.childCount || !t.childStart) {
+    for (let w = 0; w < n; w++) O(t, w, w, s, r, o);
+    return {
+      count: n,
+      positions: s,
+      colors: r,
+      covariances: o,
+      ...t.shPacked ? { shPacked: t.shPacked } : {},
+      ...t.shCodebook ? { radShCodebook: t.shCodebook } : {}
+    };
+  }
+  const i = t.childCount, c = t.childStart, a = e ? ze(i, c, n) : Ne(n), h = Ie(t.shPacked, a), u = new Uint16Array(n), d = new Uint32Array(n), f = new Float32Array(n);
+  for (let w = 0; w < n; w++) {
+    const g = a[w];
+    O(t, g, w, s, r, o), u[w] = i[g], d[w] = c[g], f[w] = Te(t.alpha[g], t.scale, g);
+  }
+  return {
+    count: n,
+    positions: s,
+    colors: r,
+    covariances: o,
+    radTree: { childCount: u, childStart: d, size: f },
+    ...h ? { shPacked: h } : {},
+    ...t.shCodebook ? { radShCodebook: t.shCodebook } : {}
+  };
+}
+function Te(t, e, n) {
+  const s = (e[n * 3] + e[n * 3 + 1] + e[n * 3 + 2]) / 3;
+  return 2 * (Math.max(t, 1) * 4 - 3) * s;
+}
+function Ne(t) {
+  const e = new Uint32Array(t);
+  for (let n = 0; n < t; n++) e[n] = n;
+  return e;
+}
+function ze(t, e, n) {
+  const s = new Uint32Array(n);
+  for (let o = 0; o < n; o++) s[o] = o;
+  const r = (o) => t[o] === 0 ? Number.MAX_SAFE_INTEGER : e[o];
+  return s.sort((o, i) => r(i) - r(o));
+}
+async function L(t, e, n, s, r) {
+  const o = new DataView(t.buffer, t.byteOffset, t.byteLength), i = o.getUint32(e, !0);
+  if (i !== ne)
+    throw new Error(`Not a RAD chunk (magic 0x${i.toString(16).padStart(8, "0")}).`);
+  const c = o.getUint32(e + 4, !0), a = e + 8 + se(c), h = JSON.parse(ie(t, e + 8, c));
+  if (h.version !== 1)
+    throw new Error(`Unsupported RAD chunk version ${h.version}.`);
+  const u = Number(o.getBigUint64(a, !0)), d = a + 8;
+  if (d + u > t.byteLength)
+    throw new Error("RAD chunk payload extends past the file.");
+  const { count: f } = h;
+  Ue(f, "chunk");
+  const w = h.lodTree ?? !1;
+  if (!Array.isArray(h.properties))
+    throw new Error("RAD chunk metadata is missing its property list.");
+  const g = h.properties, b = new Map(g.map((p) => [p.property, p])), y = async (p) => {
+    const S = b.get(p);
+    if (!S) return;
+    if (!Number.isSafeInteger(S.offset) || S.offset < 0 || !Number.isSafeInteger(S.bytes) || S.bytes < 0)
+      throw new Error(`RAD property "${p}" declares an invalid byte range.`);
+    const N = d + S.offset;
+    if (S.offset + S.bytes > u || N + S.bytes > t.byteLength)
+      throw new Error(`RAD property "${p}" extends past its chunk.`);
+    const q = t.subarray(N, N + S.bytes);
+    return S.compression === void 0 ? q : We(q);
+  }, C = w, B = [
+    "center",
+    "alpha",
+    "rgb",
+    "scales",
+    "orientation",
+    ...C ? ["child_count", "child_start"] : [void 0, void 0],
+    "sh1",
+    "sh2",
+    "sh3",
+    "sh_label",
+    "sh1_code",
+    "sh2_code",
+    "sh3_code"
+  ], [
+    E,
+    x,
+    $,
+    v,
+    F,
+    _,
+    m,
+    k,
+    P,
+    ce,
+    ae,
+    he,
+    ue,
+    de
+  ] = await Promise.all(
+    B.map((p) => p === void 0 ? Promise.resolve(void 0) : y(p))
+  );
+  if (!E) throw new Error('RAD chunk is missing its "center" property.');
+  if (!x) throw new Error('RAD chunk is missing its "alpha" property.');
+  if (!$) throw new Error('RAD chunk is missing its "rgb" property.');
+  if (!v) throw new Error('RAD chunk is missing its "scales" property.');
+  if (!F) throw new Error('RAD chunk is missing its "orientation" property.');
+  return {
+    count: f,
+    lodTree: w,
+    center: M(E, b.get("center"), 3, f),
+    alpha: M(x, b.get("alpha"), 1, f),
+    rgb: M($, b.get("rgb"), 3, f),
+    scale: M(v, b.get("scales"), 3, f),
+    quat: Re(F, b.get("orientation"), f),
+    ...C && _ ? { childCount: Se(_, b.get("child_count"), f) } : {},
+    ...C && m ? { childStart: ke(m, b.get("child_start"), f) } : {},
+    ...Le({
+      count: f,
+      byName: b,
+      sh1Raw: k,
+      sh2Raw: P,
+      sh3Raw: ce,
+      shLabelRaw: ae,
+      sh1CodeRaw: he,
+      sh2CodeRaw: ue,
+      sh3CodeRaw: de,
+      knownShCodebook: s,
+      knownShExtent: r
+    })
+  };
+}
+function Y(t) {
+  var a;
+  let e = 0;
+  for (const h of t)
+    e += h.childCount ? Ge(h.childCount) : h.count;
+  if (e === 0) throw new Error("RAD file has no leaf splats.");
+  const n = new Float32Array(e * 3), s = new Uint8Array(e * 4), r = new Float32Array(e * 6), o = (a = t.find((h) => h.shPacked)) == null ? void 0 : a.shPacked, i = o ? new Uint32Array(e * D(o.bands)) : void 0;
+  i && o && i.fill(ge(o.range));
+  let c = 0;
+  for (const h of t)
+    for (let u = 0; u < h.count; u++)
+      if (!(h.childCount && h.childCount[u] !== 0)) {
+        if (O(h, u, c, n, s, r), i && h.shPacked) {
+          const d = D(o.bands);
+          i.set(h.shPacked.packed.subarray(u * d, (u + 1) * d), c * d);
+        }
+        c++;
+      }
+  return {
+    count: e,
+    positions: n,
+    colors: s,
+    covariances: r,
+    ...o && i ? { shPacked: { ...o, packed: i } } : {}
+  };
+}
+function Ie(t, e) {
+  if (!t) return;
+  const n = D(t.bands), s = new Uint32Array(t.packed.length);
+  for (let r = 0; r < e.length; r++) {
+    const o = e[r];
+    s.set(t.packed.subarray(o * n, (o + 1) * n), r * n);
+  }
+  return { ...t, packed: s };
+}
+function Le(t) {
+  const e = [t.sh1Raw, t.sh2Raw, t.sh3Raw], n = [t.sh1CodeRaw, t.sh2CodeRaw, t.sh3CodeRaw], s = e.reduce((h, u, d) => u ? d + 1 : h, 0), r = n.reduce((h, u, d) => u ? d + 1 : h, 0);
+  if (s === 0 && r === 0 && !t.shLabelRaw) return {};
+  if (s > 0 && r > 0)
+    throw new Error("RAD chunk mixes direct and codebook SH columns.");
+  let o, i, c, a;
+  if (s > 0)
+    i = s, o = J(e, t.byName, t.count, i), a = Oe(t.byName, i) ?? t.knownShExtent;
+  else {
+    if (c = t.knownShCodebook, !c && r > 0) {
+      i = r;
+      const d = Ve(
+        n[r - 1],
+        t.byName.get(`sh${r}_code`)
+      );
+      c = {
+        bands: i,
+        count: d,
+        coefficients: J(n, t.byName, d, i, "_code")
+      };
+    }
+    if (!c) throw new Error("RAD SH labels require the codebook stored in chunk zero.");
+    if (!t.shLabelRaw)
+      throw new Error('RAD SH codebook chunk is missing its "sh_label" property.');
+    i = c.bands;
+    const h = qe(t.shLabelRaw, t.byName.get("sh_label"), t.count);
+    o = new Float32Array(t.count * D(i) * 3);
+    const u = D(i) * 3;
+    for (let d = 0; d < t.count; d++) {
+      const f = h[d];
+      if (f >= c.count)
+        throw new Error(`RAD SH label ${f} exceeds its ${c.count}-entry codebook.`);
+      o.set(
+        c.coefficients.subarray(f * u, (f + 1) * u),
+        d * u
+      );
+    }
+    a = 0;
+    for (const d of c.coefficients) a = Math.max(a, Math.abs(d));
+  }
+  return {
+    shPacked: be(o, t.count, i, a),
+    ...c ? { shCodebook: c } : {}
+  };
+}
+function Oe(t, e, n = "") {
+  let s = 0;
+  for (let r = 1; r <= e; r++) {
+    const o = t.get(`sh${r}${n}`);
+    if (!o) return;
+    let i;
+    switch (o.encoding) {
+      case "s8":
+      case "s8_delta":
+        if (o.max === void 0) return;
+        i = Math.abs(o.max);
+        break;
+      case "r8":
+      case "r8_delta":
+        if (o.min === void 0 || o.max === void 0) return;
+        i = Math.max(Math.abs(o.min), Math.abs(o.max));
+        break;
+      default:
+        return;
+    }
+    s = Math.max(s, i);
+  }
+  return s;
+}
+function J(t, e, n, s, r = "") {
+  const o = D(s), i = new Float32Array(n * o * 3);
+  let c = 0;
+  for (let a = 1; a <= s; a++) {
+    const h = t[a - 1], u = e.get(`sh${a}${r}`);
+    if (!h || !u) throw new Error(`RAD SH is missing its "sh${a}${r}" column.`);
+    const d = a === 1 ? 9 : a === 2 ? 15 : 21, f = M(h, u, d, n);
+    for (let w = 0; w < n; w++) {
+      const g = (w * o + c) * 3;
+      for (let b = 0; b < d; b++) i[g + b] = f[w * d + b];
+    }
+    c += d / 3;
+  }
+  return i;
+}
+function Ve(t, e) {
+  const n = e.property.startsWith("sh1") ? 9 : e.property.startsWith("sh2") ? 15 : 21, s = He(e);
+  if (t.byteLength % (n * s) !== 0)
+    throw new Error(`RAD "${e.property}" has an invalid SH column length.`);
+  return t.byteLength / (n * s);
+}
+function He(t) {
+  switch (t.encoding) {
+    case "f32":
+    case "f32_lebytes":
+      return 4;
+    case "f16":
+    case "f16_lebytes":
+    case "ln_f16":
+      return 2;
+    case "r8":
+    case "r8_delta":
+    case "s8":
+    case "s8_delta":
+    case "ln_0r8":
+      return 1;
+    default:
+      throw new Error(`Unsupported RAD "${t.property}" encoding "${t.encoding}".`);
+  }
+}
+function qe(t, e, n) {
+  if (e.encoding === "u16")
+    return A(t, e, 1, n, 2), Uint32Array.from(ee(t, n));
+  if (e.encoding === "u32")
+    return A(t, e, 1, n, 4), te(t, n);
+  throw new Error(`Unsupported RAD sh_label encoding "${e.encoding}".`);
+}
+function O(t, e, n, s, r, o) {
+  const i = t.alpha[e];
+  s[n * 3 + 0] = t.center[e * 3 + 0], s[n * 3 + 1] = t.center[e * 3 + 1], s[n * 3 + 2] = t.center[e * 3 + 2], r[n * 4 + 0] = T(t.rgb[e * 3 + 0] * 255), r[n * 4 + 1] = T(t.rgb[e * 3 + 1] * 255), r[n * 4 + 2] = T(t.rgb[e * 3 + 2] * 255), r[n * 4 + 3] = T(i * 0.5 * 255), we(
+    o,
+    n,
+    t.scale[e * 3 + 0],
+    t.scale[e * 3 + 1],
+    t.scale[e * 3 + 2],
+    t.quat[e * 4 + 3],
+    // w
+    t.quat[e * 4 + 0],
+    // x
+    t.quat[e * 4 + 1],
+    // y
+    t.quat[e * 4 + 2]
+    // z
+  );
+}
+function Ge(t) {
+  let e = 0;
+  for (const n of t) n === 0 && e++;
+  return e;
+}
+function T(t) {
+  return Math.max(0, Math.min(255, Math.round(t)));
+}
+function se(t) {
+  return t + 7 & -8;
+}
+function ie(t, e, n) {
+  return new TextDecoder().decode(t.subarray(e, e + n));
+}
+async function We(t) {
+  if (typeof DecompressionStream > "u")
+    throw new Error("This runtime does not provide decompression required for RAD files.");
+  const e = t[0] === 31 && t[1] === 139 ? "gzip" : t[0] === 120 ? "deflate" : "deflate-raw", n = new Uint8Array(t.byteLength);
+  n.set(t);
+  const s = new Blob([n.buffer]).stream().pipeThrough(new DecompressionStream(e));
+  return new Uint8Array(await new Response(s).arrayBuffer());
+}
+class Ye {
+  constructor(e) {
+    l(this, "chunkSize");
+    /** Parent-size ranges awaiting the child chunk that will consume them,
+     * keyed by that child chunk index. Each range is a global-index span. */
+    l(this, "pending", /* @__PURE__ */ new Map());
+    /** Chunks already resolved - a parent decoded after its child can't fix it,
+     * so we drop such stragglers rather than leak them. */
+    l(this, "resolved", /* @__PURE__ */ new Set());
+    this.chunkSize = e;
+  }
+  /**
+   * Records `chunkIndex`'s internal→child links and returns that chunk's
+   * per-splat parent sizes (in the chunk's own splat order). Call once per
+   * chunk, as it decodes.
+   *
+   * @param childCount - Per-splat child count (0 = leaf).
+   * @param childStart - Per-splat first-child global index.
+   * @param size - Per-splat LOD node size.
+   */
+  resolve(e, n, s, r) {
+    const o = n.length, i = e * this.chunkSize, c = new Float32Array(o).fill(1 / 0), a = this.pending.get(e);
+    if (a) {
+      for (const h of a) {
+        const u = Math.max(h.start - i, 0), d = Math.min(h.end - i, o);
+        for (let f = u; f < d; f++) c[f] = h.size;
+      }
+      this.pending.delete(e);
+    }
+    this.resolved.add(e);
+    for (let h = 0; h < o; h++) {
+      const u = n[h];
+      if (u === 0) continue;
+      const d = r[h];
+      let f = s[h];
+      const w = f + u;
+      for (; f < w; ) {
+        const g = Math.floor(f / this.chunkSize), b = (g + 1) * this.chunkSize, y = Math.min(w, b);
+        this.resolved.has(g) || this.push(g, f, y, d), f = y;
+      }
+    }
+    return c;
+  }
+  push(e, n, s, r) {
+    let o = this.pending.get(e);
+    o || (o = [], this.pending.set(e, o)), o.push({ start: n, end: s, size: r });
+  }
+}
+const K = 1e30, Je = 1.75, Ke = 16, X = 8, Xe = 4, je = 0.05;
+class Qe {
+  constructor(e, n, s) {
+    l(this, "budget");
+    l(this, "lodBaseDistance");
+    l(this, "lodMultiplier");
+    l(this, "chunkSize");
+    l(this, "chunkCounts");
+    l(this, "numChunks");
+    l(this, "decoded", /* @__PURE__ */ new Set());
+    /** Real bounds of a decoded chunk (AABB of its splat centers). */
+    l(this, "bounds");
+    /** Region estimated from decoded parents, to rank an undecoded chunk. */
+    l(this, "estBounds");
+    /** Per chunk: the chunks its internal splats refine into (for prefetch). */
+    l(this, "childChunks");
+    /** Inverts the tree's forward links to give each splat its parent's size,
+     * for the frontier cut. Fed the same `own_size` measure the material derives. */
+    l(this, "parentSizes");
+    /** Splats chunk 0's coarse shell draws (the minimum-coverage floor). */
+    l(this, "coverageSplatCount", 1);
+    /**
+     * Whether per-splat `parent_size` is needed. Only the GPU cuts
+     * (`foveationMode: 'band' | 'frontier'`) read `frontierParent`; the page-table
+     * pager runs its own traversal in the worker and `gatherGlobals` never carries
+     * it. Computing it anyway costs a full covariance pass per chunk *and* leaves
+     * one pending-range object per internal node alive in {@link RadParentSizes}
+     * until its child chunk decodes - tens of millions of live objects on an
+     * 800-chunk capture, enough GC pressure to read as a frozen page.
+     */
+    l(this, "needsParentSizes", !0);
+    l(this, "scratchPoint", new R.Vector3());
+    this.chunkSize = e, this.chunkCounts = n, this.numChunks = n.length, this.budget = s.budget, this.lodBaseDistance = s.lodBaseDistance, this.lodMultiplier = s.lodMultiplier, this.bounds = Array.from({ length: this.numChunks }, () => null), this.estBounds = Array.from({ length: this.numChunks }, () => null), this.childChunks = Array.from({ length: this.numChunks }, () => null), this.parentSizes = new Ye(e);
+  }
+  onChunkDecoded(e, n) {
+    if (this.decoded.has(e)) return;
+    this.decoded.add(e), this.bounds[e] = et(n);
+    const s = n.radTree;
+    if (s) {
+      const r = /* @__PURE__ */ new Set(), o = n.positions;
+      for (let i = 0; i < s.childCount.length; i++) {
+        if (s.childCount[i] === 0) continue;
+        const c = Math.floor(s.childStart[i] / this.chunkSize);
+        r.add(c);
+        let a = this.estBounds[c];
+        a || (a = new R.Box3().makeEmpty(), this.estBounds[c] = a), a.expandByPoint(
+          this.scratchPoint.set(o[i * 3] ?? 0, o[i * 3 + 1] ?? 0, o[i * 3 + 2] ?? 0)
+        );
+      }
+      this.childChunks[e] = r, this.needsParentSizes && this.attachFrontierParent(e, n, s, Ze(n));
+    }
+    e === 0 && (this.coverageSplatCount = Math.max(1, this.chunkCounts[0]));
+  }
+  /**
+   * Computes each splat's `parent_size` for the frontier cut and packs it, with
+   * a leaf-sign bit, onto `data.frontierParent` (uploaded into `covarianceB.w`).
+   *
+   * `own_size` is derived from the covariance the same way the material does -
+   * `2·√(trace(Σ)/3)`, which with the merged-node-expanded scales already carries
+   * the expansion - so a node's own size and its children's `parent_size` are the
+   * identical measure, giving clean level transitions.
+   *
+   * The catch: this source streams chunks in **camera** order, not tree order, so
+   * a child frequently decodes before its parent and `RadParentSizes` returns
+   * `Infinity` (unknown). Making every such splat a root would defeat the cut -
+   * a root always passes the "parent too big" half, so it can never be culled and
+   * the drawn count runs away. Instead an unknown parent falls back to Spark's
+   * ~1.75× merge ratio (`parent ≈ own · 1.75`), which brackets the splat to one
+   * level per ray (a per-splat band). Chunk 0 - the always-resident coarse shell -
+   * keeps the true-root sentinel so far rays always have coverage.
+   */
+  attachFrontierParent(e, n, s, r) {
+    const o = n.count, i = this.parentSizes.resolve(e, s.childCount, s.childStart, r), c = new Float32Array(o);
+    for (let a = 0; a < o; a++) {
+      let h = i[a];
+      Number.isFinite(h) || (h = e === 0 ? K : r[a] * Je), h = Math.min(h, K), c[a] = s.childCount[a] === 0 ? -h : h;
+    }
+    n.frontierParent = c;
+  }
+  computeDesiredRuns(e, n, s) {
+    const r = this.buildResident(e, n), o = [];
+    let i = 0, c = 0;
+    for (const h of r)
+      o.push(this.wholeChunkRun(h)), i += this.chunkCounts[h], c = Math.max(c, this.chunkDistance(h, e, n));
+    const a = i >= this.budget ? c : 1 / 0;
+    for (const h of this.nearestUndecodedRefinements(r, e, n, a))
+      o.push(this.wholeChunkRun(h));
+    return o;
+  }
+  /** The coarse shell covers far/loading regions via the band cull, so there
+   * are no separate substitute runs. */
+  coarsestRunsFor() {
+    return [];
+  }
+  /** Chunk 0's coarse shell plus the nearest decoded chunks, up to the budget. */
+  buildResident(e, n) {
+    const s = /* @__PURE__ */ new Set();
+    let r = 0;
+    for (let i = 0; i < Math.min(Xe, this.numChunks); i++)
+      this.decoded.has(i) && (s.add(i), r += this.chunkCounts[i]);
+    const o = [...this.decoded].filter((i) => !s.has(i)).sort(
+      (i, c) => this.chunkDistance(i, e, n) - this.chunkDistance(c, e, n)
+    );
+    for (const i of o) {
+      if (r >= this.budget) break;
+      s.add(i), r += this.chunkCounts[i];
+    }
+    return s;
+  }
+  nearestUndecodedRefinements(e, n, s, r) {
+    const o = /* @__PURE__ */ new Set();
+    for (const i of e) {
+      const c = this.childChunks[i];
+      if (c)
+        for (const a of c)
+          !this.decoded.has(a) && this.chunkDistance(a, n, s) <= r && o.add(a);
+    }
+    return [...o].sort(
+      (i, c) => this.refineScore(c, n, s) - this.refineScore(i, n, s)
+    ).slice(0, Ke);
+  }
+  /** Refine priority for an undecoded chunk (higher = sooner): nearest, in-view
+   * region first, scored against its *localized* estimated bounds (not the
+   * scene-spanning whole-chunk bounds). Off-screen regions - not drawn - are
+   * strongly penalized so the surfaces the camera faces refine first. */
+  refineScore(e, n, s) {
+    const r = this.estBounds[e] ?? this.bounds[e];
+    if (!r) return 0;
+    const o = Math.max(r.distanceToPoint(n), je);
+    return (s.intersectsBox(r) ? 1 : 1 / X) / o;
+  }
+  chunkDistance(e, n, s) {
+    const r = this.bounds[e] ?? this.estBounds[e];
+    if (!r) return 1 / 0;
+    const o = r.distanceToPoint(n);
+    return s.intersectsBox(r) ? o : o * X;
+  }
+  /** One run covering a whole chunk; the material cull selects splats within. */
+  wholeChunkRun(e) {
+    return {
+      file: e,
+      level: this.numChunks - e,
+      offset: 0,
+      count: this.chunkCounts[e],
+      leafStart: e,
+      leafEnd: e + 1
+    };
+  }
+}
+function Ze(t) {
+  const e = t.count, n = t.covariances, s = new Float32Array(e);
+  for (let r = 0; r < e; r++) {
+    const o = n[r * 6] + n[r * 6 + 3] + n[r * 6 + 5];
+    s[r] = 2 * Math.sqrt(Math.max(o, 0) / 3);
+  }
+  return s;
+}
+function et(t) {
+  const e = new R.Box3(), n = new R.Vector3(), s = t.positions;
+  for (let r = 0; r < t.count; r++)
+    n.set(s[r * 3] ?? 0, s[r * 3 + 1] ?? 0, s[r * 3 + 2] ?? 0), e.expandByPoint(n);
+  return e.isEmpty() ? new R.Box3(new R.Vector3(-1, -1, -1), new R.Vector3(1, 1, 1)) : e;
+}
+const tt = 6;
+async function Rt(t, e, n, s = 3, r = !0) {
+  var F, _;
+  const { meta: o, chunksStart: i } = await ut(t.manifestUrl, n), c = o.chunkSize ?? o.count;
+  if (o.chunks.length === 0) throw new Error("RAD file has no chunks.");
+  const h = o.chunks.map((m, k) => {
+    if (m.filename === void 0) return `${t.manifestUrl}#rad-chunk-${k}`;
+    const P = t.resolve(m.filename);
+    if (P === null)
+      throw new Error(`RAD chunk ${k} references a missing file "${m.filename}".`);
+    return P;
+  });
+  let u = o.chunks.map((m) => ({
+    format: "rad-chunk",
+    rad: m.filename === void 0 ? { start: i + m.offset, length: m.bytes } : {}
+  }));
+  const d = rt(o.comment) ?? o.count, f = r ? ye(e.budget, d) : e.budget, w = d > nt || d > f, g = o.chunks[0], b = g.filename === void 0 ? await V(
+    t.manifestUrl,
+    i + g.offset,
+    g.bytes,
+    n
+  ) : await dt(h[0], n), y = await Be(b, void 0, void 0, !w), C = (F = y.shPacked) == null ? void 0 : F.range.max[0];
+  (y.radShCodebook || C !== void 0) && (u = u.map((m) => ({
+    ...m,
+    rad: {
+      ...m.rad,
+      ...y.radShCodebook ? { shCodebook: y.radShCodebook } : {},
+      ...C !== void 0 ? { shExtent: C } : {}
+    }
+  })));
+  const B = ct(y), E = it(y.positions, y.count), x = s === 0 ? 0 : ((_ = y.shPacked) == null ? void 0 : _.bands) ?? 0, $ = o.chunks.map(
+    (m, k) => Math.min(c, o.count - k * c)
+  );
+  if (w) {
+    const m = new Qe(c, $, e);
+    return y.radTree && m.onChunkDecoded(0, y), {
+      source: m,
+      chunkUrls: h,
+      chunkKind: "file",
+      // File order (no leaves-first reorder): the band cull is order-agnostic
+      // and this keeps `child_start` valid for future exact-parent-size work.
+      chunkOptions: u.map((k) => ({
+        ...k,
+        rad: { ...k.rad, reorder: !1 }
+      })),
+      shBands: x,
+      bounds: B,
+      pinnedFiles: /* @__PURE__ */ new Set([0]),
+      // Pool holds the resident set (near + coarse), not the whole tree.
+      maxResidentSplats: e.budget,
+      // The real capture size, which `maxResidentSplats` cannot carry here (it
+      // echoes the caller's budget). A host splitting one budget across several
+      // streamed meshes needs it: a mesh cannot spend more than it contains.
+      contentSplatCount: d,
+      minimumCoverageSplats: m.coverageSplatCount,
+      foveation: ot,
+      chunkSize: c,
+      overviewPositions: E,
+      // Hand chunk 0 straight to the page-table worker: it holds the tree roots,
+      // so until it lands every traversal returns an empty frontier. Its buffers
+      // are transferred there, so nothing may read `chunk0Data` after this.
+      bootstrapChunk: { file: 0, data: y }
+    };
+  }
+  const v = new at(o.count, c, $, e);
+  return y.radTree && v.onChunkDecoded(0, y), {
+    source: v,
+    chunkUrls: h,
+    chunkKind: "file",
+    chunkOptions: u,
+    shBands: x,
+    bounds: B,
+    pinnedFiles: /* @__PURE__ */ new Set([0]),
+    maxResidentSplats: d,
+    contentSplatCount: d,
+    minimumCoverageSplats: v.coverageSplatCount,
+    overviewPositions: E
+  };
+}
+const nt = 6e6, ot = { minScreenRadiusPx: 1.6, maxScreenRadiusPx: 4 };
+function rt(t) {
+  if (t)
+    try {
+      const n = JSON.parse(t).input_splat_count;
+      return typeof n == "number" && Number.isFinite(n) && n > 0 ? n : void 0;
+    } catch {
+      return;
+    }
+}
+const st = 8192;
+function it(t, e) {
+  if (e <= 0) return new Float32Array(0);
+  const n = Math.max(1, Math.floor(e / st));
+  let s = 0;
+  for (let i = 0; i < e; i += n) s++;
+  const r = new Float32Array(s * 3);
+  let o = 0;
+  for (let i = 0; i < e; i += n) {
+    const c = i * 3;
+    r[o++] = t[c], r[o++] = t[c + 1], r[o++] = t[c + 2];
+  }
+  return r;
+}
+function ct(t) {
+  const e = new R.Box3(), n = new R.Vector3(), s = t.positions;
+  for (let r = 0; r < t.count; r++)
+    n.set(s[r * 3] ?? 0, s[r * 3 + 1] ?? 0, s[r * 3 + 2] ?? 0), e.expandByPoint(n);
+  return e.isEmpty() ? new R.Box3(new R.Vector3(-1, -1, -1), new R.Vector3(1, 1, 1)) : e;
+}
+class at {
+  constructor(e, n, s, r) {
+    l(this, "budget");
+    l(this, "lodBaseDistance");
+    l(this, "lodMultiplier");
+    l(this, "total");
+    l(this, "chunkSize");
+    l(this, "chunkCounts");
+    l(this, "numChunks");
+    /**
+     * Decoded per-splat tree columns, by chunk index.
+     *
+     * Grows monotonically and is deliberately never evicted. That costs ~10 B per
+     * splat of every chunk ever decoded (`childCount` u16 + `childStart` u32 +
+     * `size` f32) and is invisible to the chunk cache's byte accounting, so it
+     * reads like a leak - but it is not reclaimable. {@link discoveredDepth} is
+     * the longest *contiguous* decoded prefix and every frontier walk at or below
+     * it reads these columns, so dropping an entry would either corrupt the
+     * traversal or force `discoveredDepth` back and visibly coarsen the scene.
+     *
+     * Bounded in practice by the mode that uses it: `.rad` defaults to
+     * `foveationMode: 'pagetable'`, where the frontier worker owns the traversal
+     * and this source is never constructed. Only the `'band'` and `'frontier'`
+     * A/B modes pay it. Reducing it means changing the tree encoding, not adding
+     * an eviction pass here.
+     */
+    l(this, "decoded", /* @__PURE__ */ new Map());
+    /** Longest contiguous decoded prefix `{0 … discoveredDepth − 1}`. */
+    l(this, "discoveredDepth", 0);
+    /** Chunk-0-only frontier: the always-available coarse substitute coverage. */
+    l(this, "coarseRuns", []);
+    /** Splats the coarse (chunk-0) coverage draws. */
+    l(this, "coverageSplatCount", 1);
+    /** Cache of the last emitted frontier, keyed by the inputs that shape it. */
+    l(this, "cachedRuns", []);
+    l(this, "cachedFrontierCount", 0);
+    /** Frontier splat count by prefix depth; see {@link countAtDepth}. */
+    l(this, "depthCounts", /* @__PURE__ */ new Map());
+    /** Budget range over which {@link cachedRuns} stays the correct frontier. */
+    l(this, "cachedBudgetLo", Number.POSITIVE_INFINITY);
+    l(this, "cachedBudgetHi", Number.NEGATIVE_INFINITY);
+    l(this, "cachedForDiscovered", -1);
+    this.total = e, this.chunkSize = n, this.chunkCounts = s, this.numChunks = s.length, this.budget = r.budget, this.lodBaseDistance = r.lodBaseDistance, this.lodMultiplier = r.lodMultiplier;
+  }
+  onChunkDecoded(e, n) {
+    if (!(!n.radTree || this.decoded.has(e)))
+      for (this.decoded.set(e, n.radTree), e === 0 && (this.coarseRuns = this.frontierRuns(1, this.chunkCounts[0]), this.coverageSplatCount = Math.max(1, ht(this.coarseRuns))); this.decoded.has(this.discoveredDepth); ) this.discoveredDepth++;
+  }
+  computeDesiredRuns(e, n, s) {
+    if (this.ensureFrontier(), this.cachedFrontierCount >= this.budget) return this.cachedRuns;
+    const r = [...this.cachedRuns], o = Math.min(this.discoveredDepth + tt, this.numChunks);
+    for (let i = this.discoveredDepth; i < o; i++)
+      this.decoded.has(i) || r.push(this.fetchIntentRun(i));
+    return r;
+  }
+  coarsestRunsFor(e, n) {
+    const s = [];
+    for (const r of this.coarseRuns)
+      r.leafStart < n && r.leafEnd > e && s.push(r);
+    return s;
+  }
+  /**
+   * Recomputes the cached frontier when the budget or discovery has moved.
+   *
+   * The cache is keyed on the *range* of budgets that select the same prefix
+   * depth, not on the budget itself. A camera-weighted governor rewrites the
+   * budget every frame - it wanders by a few percent as the camera drifts - and
+   * an exact-equality key therefore missed on roughly a third of all calls while
+   * choosing the very same depth. Each of those misses re-walks `frontierRuns`
+   * over the whole decoded prefix (millions of splats, several times over if it
+   * steps down levels): measured at 33ms mean and 1.1s worst, it was 92% of all
+   * frame CPU on a marker-heavy scene. Frontier count rises monotonically with
+   * depth, so the selected depth is stable for any budget in
+   * `[thisDepthCount, nextDepthCount)` and the walk can be skipped outright.
+   */
+  ensureFrontier() {
+    if (this.cachedForDiscovered === this.discoveredDepth && this.budget >= this.cachedBudgetLo && this.budget < this.cachedBudgetHi)
+      return;
+    this.cachedForDiscovered = this.discoveredDepth;
+    let e = this.discoveredDepth, n = e > 0 ? this.countAtDepth(e) : 0, s = Number.POSITIVE_INFINITY;
+    for (; e > 1 && n > this.budget; )
+      s = n, e--, n = this.countAtDepth(e);
+    const r = e > 0 ? this.frontierRuns(e, Math.min(e * this.chunkSize, this.total)) : [];
+    this.cachedRuns = r, this.cachedFrontierCount = n, this.cachedBudgetLo = e > 1 ? n : 0, this.cachedBudgetHi = s;
+  }
+  /**
+   * Splats the frontier draws at `depth`, memoized.
+   *
+   * `discoveredDepth` is the longest *contiguous* decoded prefix, so for any
+   * `depth <= discoveredDepth` every chunk the walk reads is already decoded and
+   * the answer can never change afterwards - chunks are only ever added to
+   * `decoded`. That makes this permanently cacheable, which is what lets the
+   * depth search above run without rebuilding runs at each level it rejects.
+   */
+  countAtDepth(e) {
+    const n = this.depthCounts.get(e);
+    if (n !== void 0) return n;
+    const s = Math.min(e * this.chunkSize, this.total);
+    let r = 0;
+    for (let o = 0; o < e; o++) {
+      const i = this.decoded.get(o);
+      if (!i) continue;
+      const c = this.chunkCounts[o];
+      for (let a = 0; a < c; a++)
+        (i.childCount[a] === 0 || i.childStart[a] >= s) && r++;
+    }
+    return this.depthCounts.set(e, r), r;
+  }
+  /**
+   * The rendered runs for a resident prefix of `depth` chunks: within each
+   * chunk, the contiguous ranges of splats that are leaves or whose children
+   * fall beyond `residentCount` (the prefix's total splat count). The chunk's
+   * splats are child-start-descending (leaves first), so each range coalesces
+   * into one run.
+   */
+  frontierRuns(e, n) {
+    const s = [];
+    for (let r = 0; r < e; r++) {
+      const o = this.decoded.get(r);
+      if (!o) continue;
+      const i = this.chunkCounts[r], c = r * this.chunkSize, a = this.numChunks - r;
+      let h = -1;
+      for (let u = 0; u < i; u++)
+        o.childCount[u] === 0 || o.childStart[u] >= n ? h < 0 && (h = u) : h >= 0 && (s.push(I(r, a, h, u, c)), h = -1);
+      h >= 0 && s.push(I(r, a, h, i, c));
+    }
+    return s;
+  }
+  fetchIntentRun(e) {
+    const n = this.chunkCounts[e];
+    return I(e, this.numChunks - e, 0, n, e * this.chunkSize);
+  }
+}
+function I(t, e, n, s, r) {
+  return { file: t, level: e, offset: n, count: s - n, leafStart: r + n, leafEnd: r + s };
+}
+function ht(t) {
+  let e = 0;
+  for (const n of t) e += n.count;
+  return e;
+}
+async function ut(t, e) {
+  let s = await V(t, 0, 262144, e, !0);
+  const r = new DataView(s);
+  if (r.byteLength >= 8) {
+    const o = r.getUint32(4, !0);
+    8 + o > s.byteLength && (s = await V(t, 0, 8 + o, e));
+  }
+  return re(s);
+}
+async function V(t, e, n, s, r = !1) {
+  const o = j(s), i = await fetch(t, {
+    ...o,
+    headers: { ...(s == null ? void 0 : s.headers) ?? {}, Range: `bytes=${e}-${e + n - 1}` }
+  });
+  if (!i.ok)
+    throw new Error(`Failed to load ${t}: HTTP ${i.status}`);
+  if (i.status !== 206 && !(r && i.status === 200))
+    throw new Error(
+      `${t} ignored a Range request (HTTP ${i.status}); single-file .rad streaming needs a server that answers 206 Partial Content.`
+    );
+  const c = await i.arrayBuffer();
+  if (!r && c.byteLength !== n)
+    throw new Error(`${t} returned ${c.byteLength} bytes for a ${n}-byte range.`);
+  return c;
+}
+async function dt(t, e) {
+  const n = await fetch(t, j(e));
+  if (!n.ok) throw new Error(`Failed to load ${t}: HTTP ${n.status}`);
+  return n.arrayBuffer();
+}
+export {
+  ne as RAD_CHUNK_MAGIC,
+  Me as RAD_MAGIC,
+  at as RadLodSource,
+  Rt as buildRadScene,
+  mt as parseRad,
+  Be as parseRadChunkStreaming,
+  re as parseRadHeaderMeta
+};
+//# sourceMappingURL=rad.js.map