@voluma/vlam 0.2.4 → 0.3.0

package/dist/splat-mesh-types-BZIko-_9.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splat-mesh-types-BZIko-_9.js","sources":["../src/lib/splat-mesh-types.ts"],"sourcesContent":["/** Public configuration and result types for SplatMesh. */\nimport type * as THREE from 'three/webgpu';\nimport type { SplatData } from './splat-data';\nimport type { SplatOrientation } from './orientation';\nimport type { SplatModifier } from './splat-modifier';\nimport {\n  detectSplatDeviceProfile,\n  isFillConstrainedSplatDevice,\n  type SplatDeviceProfile,\n} from './splat-budget';\nimport type { SplatPool } from './splat-mesh-pool';\nimport type { SplatShInputs, Vec3Uniform } from './splat-mesh-material';\n\n/** Construction-time projected-footprint policy selected by a streamed format. */\nexport type ProjectedFilterProfile = 'default' | 'lcc';\n\n/** Canonical `.rad` foveation modes. */\nexport type SplatFoveationMode = 'band' | 'frontier' | 'page-table';\n\n/** Resolve a caller-supplied foveation mode, defaulting when unset. */\nexport function resolveSplatFoveationMode(\n  mode: SplatFoveationMode | undefined,\n  fallback: SplatFoveationMode = 'band',\n): SplatFoveationMode {\n  return mode ?? fallback;\n}\n\n/** True when the mode is the `.rad` page-table pager. */\nexport function isPageTableFoveation(mode: string | undefined): boolean {\n  return mode === 'page-table';\n}\n\n/**\n * Opaque handle for a range of splats appended to a {@link SplatMesh},\n * used to remove the range again.\n */\nexport interface SplatRange {\n  /** Number of splats in this range. */\n  readonly count: number;\n}\n\n/**\n * Storage format of a per-splat channel (see {@link SplatMesh.defineChannel}).\n *\n *  - `'byte'`: one `Uint8` per splat (`r8unorm`). Compact - a good fit for\n *    masks and labels. `ctx.channel(name)` reads it back **normalized** to\n *    `[0, 1]`, so a painted `255` reads as `1.0`.\n *  - `'float'`: one `Float32` per splat (`r32float`), read back verbatim.\n */\nexport type SplatChannelType = 'byte' | 'float';\n\n/** Options for {@link SplatMesh.defineChannel}. */\nexport interface SplatChannelOptions {\n  /** Storage format; default `'float'`. */\n  type?: SplatChannelType;\n  /**\n   * Value every splat starts at before any {@link SplatMesh.writeChannel}.\n   * Default `0`. For `'byte'` channels this is a raw `0..255` value.\n   */\n  fill?: number;\n}\n\n/** The highest SH order this renderer evaluates (3rd → 15 coefficients). */\nexport const MAX_SH_BANDS = 3;\n\n/**\n * The contribution-culling profile a mesh will use, given an optional\n * explicit override. Exported so callers that must decide something *before*\n * constructing the mesh - such as whether a streamed scene should fetch its\n * SH at all - agree with what the mesh itself will pick.\n */\nexport function resolveSplatPerformanceProfile(\n  explicit?: SplatPerformanceProfile,\n  profile: SplatDeviceProfile | undefined = detectSplatDeviceProfile(),\n): SplatPerformanceProfile {\n  return explicit ?? (isFillConstrainedSplatDevice(profile) ? 'smooth' : 'quality');\n}\n\n/** Construction options for {@link SplatMesh}. */\nexport interface SplatMeshOptions {\n  /**\n   * Storage for per-splat higher-order SH in a dynamic-capacity pool, in\n   * bands (1, 2 or 3 → 3, 8 or 15 coefficients per channel); 0 (default)\n   * allocates nothing.\n   *\n   * Only formats that store SH per splat can fill this - LCC `Quality`, `.rad`, etc.\n   * It costs 16 bytes per splat per band-group of four\n   * coefficients (64 B/splat at 3 bands), so it is opt-in. On a static mesh\n   * this is ignored: packed SH is taken from `source.shPacked` when present,\n   * otherwise palette `source.sh` (SOG).\n   */\n  shBands?: 0 | 1 | 2 | 3;\n  /**\n   * Minimum interval between WebGPU sorts while the camera moves. When\n   * omitted, the interval adapts to the active splat count. Use `0` to sort\n   * every changed frame. WebGL worker sorting is unaffected.\n   */\n  sortIntervalMs?: number;\n  /**\n   * WebGPU sorter used for A/B validation. Defaults to the proven counting\n   * sorter. `'radix'` keeps the fast 24-bit key path; `'exact'` lazy-loads a\n   * stable 32-bit Float32-depth radix path that avoids scene-range\n   * quantization. The first frames may skip sorting until the module resolves.\n   *\n   * @experimental Radix strategies may change in a minor release.\n   */\n  sortStrategy?: SplatSortStrategy;\n  /**\n   * Render-quality policy. `smooth` rejects negligible projected contributions.\n   *\n   * The default is device-aware: `smooth` on mobile (where rejecting splats too\n   * small or too faint to see is worth far more than it costs), `quality`\n   * everywhere else. Passing a value opts out of the detection.\n   */\n  performanceProfile?: SplatPerformanceProfile;\n  /**\n   * How far out, in standard deviations, each Gaussian is drawn before it is\n   * cut off. Every splat is an alpha-blended quad sized to this radius, so it\n   * sets how much each one costs to blend - the dominant cost in a busy view.\n   * Lowering it shrinks every quad and clips the faint outer tail of each\n   * Gaussian; the falloff within the remaining radius is unchanged.\n   *\n   * Defaults to `3`, the reference 3DGS rasterizer's radius. Below ~2 the\n   * truncation shows as visible splat edges; much above ~5 the extra fill is not\n   * worth it. Mobile coverage gaps are handled by `minSplatSizePx` instead of\n   * growing every splat.\n   */\n  maxStdDev?: number;\n  /**\n   * Floor, in viewport pixels, on each rendered splat's projected quad radius.\n   *\n   * A screen-space *minimum* size, the counterpart to `maxScreenRadiusPx`'s\n   * maximum. When a splat projects smaller than this - because it is distant, or\n   * because the whole scene is zoomed out - its quad is grown to this radius and\n   * the Gaussian is stretched to fill it (the falloff normalizes to the quad, so\n   * no hard edge appears). Splats already larger are untouched, so it costs no\n   * extra fill on the near-camera splats that dominate overdraw.\n   *\n   * This is the fix for the \"dark gaps when zoomed out\" failure mode: a capture\n   * whose finest splats are spaced farther apart than their footprint leaves the\n   * background showing between them, and the effect is worst at low resolution -\n   * i.e. on a phone. Raising `maxStdDev` also closes the gaps but inflates\n   * *every* splat's fragment count by its square, paying the coverage cost on the\n   * large splats too; this floor spends it only where a gap can actually open.\n   *\n   * Defaults to `1.5` px on mobile and `0` (disabled) elsewhere, including\n   * fill-constrained desktops. Values around 1–3 px close typical gaps; too\n   * large a floor blurs distinct small features into discs, so tune it up from\n   * small on the target device. An explicit `0` always disables the floor.\n   */\n  minSplatSizePx?: number;\n  /**\n   * Apply the Mip-Splatting 2D antialiasing filter - the screen-space low-pass\n   * dilation plus the opacity compensation that conserves each Gaussian's\n   * integral, so small/distant splats stop over-brightening. Match the\n   * exporter: enable it for scenes trained/exported with antialiasing (the SOG\n   * `antialias` meta flag sets this automatically). Defaults to `false` (the\n   * classic 3DGS dilation without compensation).\n   */\n  antialias?: boolean;\n  /**\n   * Internal format-selected reconstruction profile. Classic LCC uses the\n   * XGRIDS-compatible 0.1 px² compensated low-pass; callers should leave this\n   * unset and select a format through {@link StreamedSplatMesh.load} instead.\n   *\n   * @internal\n   */\n  projectedFilterProfile?: ProjectedFilterProfile;\n  /**\n   * Emit splat colors in sRGB (display) space instead of decoding them to the\n   * renderer's linear working space. Pair with a renderer that skips output\n   * conversion (`outputColorSpace = LinearSRGBColorSpace`, `NoToneMapping`,\n   * inline sRGB encode for other materials via `renderer.contextNode`): splats\n   * then alpha-composite on gamma-encoded values - the math 3DGS training\n   * optimizes against, and what WebGL splat viewers render. Defaults to\n   * `false` (linear working-space compositing).\n   */\n  srgbOutput?: boolean;\n  /**\n   * Cull any splat whose projected on-screen radius exceeds this many pixels,\n   * rendering a hole instead. A physically large splat close to the camera -\n   * a coarse merged LOD node (a Spark `.rad` \"blob\"), or a giant background\n   * Gaussian - projects huge while a fine surface splat stays small, so this\n   * removes the near-camera blobs without touching detailed geometry. `0` or\n   * unset disables it (the default). Baked into the material graph.\n   */\n  maxSplatScreenRadius?: number;\n  /**\n   * Foveation band lower bound (px): cull any splat whose projected on-screen\n   * radius is *below* this. Paired with {@link maxSplatScreenRadius}, only\n   * splats sized `(min, max]` on screen draw. Because a `.rad` LOD tree's node\n   * sizes shrink geometrically, exactly one level per view ray lands in the\n   * band - near rays on fine leaves, far rays on coarse nodes - giving a\n   * camera-distance foveated cut. `0` or unset disables it (the default).\n   * Baked into the material graph. See `docs/formats/rad-notes.md` M14.6.\n   */\n  minSplatScreenRadius?: number;\n  /**\n   * How a `.rad` foveated mesh picks its per-splat LOD cut:\n   * - `'band'` (default): the screen-radius band above\n   *   ({@link minSplatScreenRadius}, {@link maxSplatScreenRadius}].\n   * - `'frontier'`: Spark's exact tree cut - draw splat `i` iff its parent is\n   *   too big and it is small enough (`parentPixelScale > limit ≥ ownPixelScale`),\n   *   using per-splat `own_size`/`parent_size`. Full coverage by construction, no\n   *   band leapfrogging. Baked into the material graph. See `docs/formats/rad-notes.md`.\n   * - `'page-table'`: the {@link StreamedSplatMesh} default for `.rad` - a worker\n   *   owns the tree traversal and pages only the *selected* frontier into the\n   *   pool (Spark's selected-index model), so the whole splat budget buys\n   *   on-screen detail. Requires the streamed `.rad` machinery; on a plain\n   *   `SplatMesh` it has no worker to drive it.\n   *\n   * @experimental `.rad` foveation option; may change in a minor release.\n   */\n  foveationMode?: SplatFoveationMode;\n  /**\n   * Target on-screen size (px) for the frontier / page-table cut: it keeps one\n   * LOD level per view ray whose projected node size is about this. Larger =\n   * coarser/fewer splats, smaller = finer/denser. Default\n   * {@link DEFAULT_FOVEATION_TARGET_PX} (1, matching Spark's `lodRenderScale`),\n   * so the draw budget rather than the cut size is what bounds detail. Raise it\n   * to trade sharpness for fill rate on weak GPUs.\n   * Acts as the *finest* bound: the adaptive limit coarsens above it to hold the\n   * draw budget but never dips below it.\n   *\n   * @experimental `.rad` foveation option; may change in a minor release.\n   */\n  foveationTargetPx?: number;\n  /**\n   * Target upper bound on the number of splats the frontier cut *draws*\n   * (Spark's `maxSplats`). Each reschedule the cut's `pixelScaleLimit`\n   * self-adjusts - coarsening when the estimated drawn count exceeds this - so\n   * frame cost stays bounded as detail streams in. Default\n   * {@link DEFAULT_FOVEATION_DRAW_BUDGET}. Only used in `'frontier'` mode.\n   *\n   * @experimental `.rad` foveation option; may change in a minor release.\n   */\n  foveationDrawBudget?: number;\n  /**\n   * Cap on a rendered splat's major/minor axis ratio (`0`/unset = off). A very\n   * anisotropic Gaussian (a flat 3DGS disk edge-on, or an expansion-enlarged\n   * coarse LOD node) otherwise projects to a long needle; this bounds its drawn\n   * length to `maxSplatAspect`× its width. Baked into the material graph.\n   *\n   * @experimental `.rad` foveation option; may change in a minor release.\n   */\n  maxSplatAspect?: number;\n  /**\n   * Spark's LOD alpha encoding (`.rad`): the stored opacity is `alpha/2` so the\n   * shader recovers `alpha ∈ [0,2]`, and `alpha > 1` marks a merged node rendered\n   * with a grown σ-cutoff + super-Gaussian falloff. Set for foveated `.rad`.\n   *\n   * @experimental `.rad` foveation option; may change in a minor release.\n   */\n  lodAlpha?: boolean;\n  /**\n   * How the scene is oriented into the three.js Y-up world. `'y-up'` (default)\n   * normalizes every known format to Y-up - 3DGS Y-down formats\n   * (PLY/`.splat`/`.ksplat`/SOG) are flipped 180° about X; SPZ/`.rad` are\n   * already Y-up; LCC keeps its own Z-up→Y-up matrix. `'source'` applies no\n   * cosmetic flip and renders in the data frame (raw Spark / mkkellogg parity);\n   * LCC still self-orients (that is format semantics, not part of the switch).\n   *\n   * For a fully loaded mesh the flip is chosen from {@link SplatData.format}\n   * (stamped by the loaders); a dynamic-capacity mesh carries no format, so the\n   * caller applies {@link yUpTransformForFormat} itself. See {@link SplatOrientation}.\n   */\n  orientation?: SplatOrientation;\n  /**\n   * GPU storage type for the pool's continuous float textures (`centers` and\n   * `covarianceA`). `'float16'` uploads them as `rgba16float` (~16 B/splat\n   * saved vs the default). CPU backing stays float32 (sorter, query, writes).\n   *\n   * `covarianceB` is always float32: it packs integer IDs (SOG palette labels,\n   * RAD frontier parents) that half floats cannot represent exactly above\n   * 2048. Colors and packed SH are unchanged. Construction-time only.\n   */\n  poolFloatTextures?: 'float32' | 'float16';\n  /**\n   * An existing pool to draw from instead of allocating one.\n   *\n   * Several meshes sharing a pool share its memory envelope: rows go to\n   * whichever mesh needs them, so a mesh the camera is near can hold far more\n   * than an even split would give it, and one that is far away holds almost\n   * nothing - without every mesh having reserved a private ceiling up front.\n   * This is the multi-mesh analogue of a single streamed mesh's LOD budget.\n   *\n   * The pool is *not* owned by the mesh: {@link SplatMesh.dispose} releases the\n   * mesh's rows and leaves the textures alone, so the pool's creator disposes\n   * it once every tenant is gone. `capacity` on the source is then only used\n   * for the mesh's own draw list, not to size storage.\n   *\n   * Sharing costs a whole-pool stall when the pool fragments - see\n   * {@link SplatMesh.compact}.\n   */\n  pool?: SplatPool;\n  /**\n   * The device's `maxTextureDimension2D`, forwarded to a pool this mesh\n   * allocates for itself so an over-tall pool fails at construction with a\n   * readable error instead of at first draw. Pass `deviceMaxTextureSize(renderer)`.\n   *\n   * Ignored when {@link SplatMeshOptions.pool} supplies the pool - that pool\n   * was already checked when its creator built it.\n   */\n  maxTextureSize?: number;\n}\n\n/** Available WebGPU depth-sort implementations. */\nexport type SplatSortStrategy = 'counting' | 'radix' | 'exact';\n\n/** Controls optional work during a per-frame source update. */\nexport interface SplatUpdateOptions {\n  /** Leave sorting to {@link UnifiedSplatMesh}; uploads and LOD state still update. */\n  sort?: boolean;\n}\n\n/**\n * Read-only GPU-facing view of a mesh's current active pool. It is consumed by\n * the M15.4 unified gather path; streamed meshes expose their current LOD cut\n * through the same view because they inherit {@link SplatMesh}.\n *\n * @experimental May change in a minor release.\n */\nexport interface UnifiedSourceView {\n  /** Total addressable pool slots. */\n  readonly capacity: number;\n  /** Pool indices of active splats, packed from zero. */\n  readonly sourceIndex: THREE.StorageBufferAttribute;\n  /** Active entries at the front of {@link sourceIndex}. */\n  readonly activeCount: number;\n  /** Local-space centers, RGBA32F and pool-indexed. */\n  readonly centersTexture: THREE.DataTexture;\n  /** Source display color and opacity, RGBA8 and pool-indexed. */\n  readonly colorsTexture: THREE.DataTexture;\n  /** Upper covariance rows, RGBA32F and pool-indexed. */\n  readonly covarianceATexture: THREE.DataTexture;\n  /** Final covariance row, RGBA32F and pool-indexed. */\n  readonly covarianceBTexture: THREE.DataTexture;\n  /** Centers texture row width. */\n  readonly dataTextureWidth: number;\n  /** Current source-local → world transform. */\n  readonly matrixWorld: THREE.Matrix4;\n  /** Conservative world-space bound for depth quantization. */\n  readonly worldBounds: THREE.Sphere;\n  /** Higher-order color data resolved by the gather pass when present. */\n  readonly sh: SplatShInputs | null;\n  /** Effect hooks and their source-local data channels. */\n  readonly modifiers: readonly SplatModifier[];\n  /**\n   * True when this source is itself a unified pool with per-source placement\n   * (`MergedSplatMesh`). The gather path cannot resolve nested placement, so\n   * `UnifiedSplatMesh` rejects these sources.\n   */\n  readonly hasSourcePlacement: boolean;\n  readonly channels: ReadonlyMap<string, { texture: THREE.DataTexture }>;\n  /** Same uniform node the source graph updates each frame. */\n  readonly localCameraPosition: Vec3Uniform;\n  /** Changes whenever a modifier graph must be rebuilt. */\n  readonly graphRevision: number;\n  /** Whether this source intentionally composites in display (sRGB) space. */\n  readonly srgbOutput: boolean;\n  /** Shared draw-path settings that must agree across unified sources. */\n  readonly maxStdDev: number;\n  /** Screen-space minimum splat radius, px (0 = off). */\n  readonly minSplatSizePx: number;\n  readonly antialias: boolean;\n  /** Construction-time projected-footprint policy shared by one unified pass. */\n  readonly projectedFilterProfile: ProjectedFilterProfile;\n  /**\n   * Whether this source stores Spark LOD alpha (`alpha ÷ 2`, `.rad`). The\n   * gather recovers the full `alpha ∈ [0,2]`; the draw material then treats\n   * `alpha > 1` as a merged node. Per source, not a compatibility field - a\n   * scene may mix `.rad` and non-`.rad` sources.\n   */\n  readonly lodAlpha: boolean;\n  /** Increments whenever pool-backed data or active residency changes. */\n  readonly contentRevision: number;\n}\n\n/** Quality-compatible rendering or smoother contribution-culling rendering. */\nexport type SplatPerformanceProfile = 'quality' | 'smooth';\n\n/**\n * Options for {@link SplatMesh.pick}.\n *\n * Picking returns the selected splat's rendered center plane (depth-tested\n * Gaussian coverage), not a persistent splat identifier or a collision mesh.\n */\nexport interface SplatPickOptions {\n  /**\n   * Minimum Gaussian opacity (after falloff × splat alpha) for a fragment to\n   * count as a hit. Default `0.1`.\n   */\n  alphaThreshold?: number;\n}\n\n/**\n * Result of a successful {@link SplatMesh.pick}.\n *\n * The point lies on the frontmost splat's billboard plane at the picked\n * pixel - suitable for click-to-focus and placement anchors, not physics.\n */\nexport interface SplatPickResult {\n  /** Hit position in world space. */\n  readonly point: THREE.Vector3;\n  /** Distance from the camera position to {@link point}. */\n  readonly distance: number;\n}\n\n/**\n * Result of {@link SplatMesh.queryNearest}: the resident splat center closest\n * to the query point, in world space.\n */\nexport interface SplatNearestResult {\n  /** The splat's center, in world space. */\n  readonly point: THREE.Vector3;\n  /** World-space distance from the query point to {@link point}. */\n  readonly distance: number;\n}\n\n/** Result of a successful synchronous {@link SplatMesh.queryRay}. */\nexport interface SplatRayResult {\n  /** Resident splat center in world space. */\n  readonly point: THREE.Vector3;\n  /** Distance along the ray from its origin to the center's closest plane. */\n  readonly distance: number;\n}\n\n/**\n * Result of {@link SplatMesh.queryHeight}: the supporting surface found beneath\n * the query point (the highest resident splat within the drop and horizontal\n * radius), in world space.\n */\nexport interface SplatHeightResult {\n  /** The supporting splat's center, in world space. */\n  readonly point: THREE.Vector3;\n  /** How far below the query point the surface sits (world units, ≥ 0). */\n  readonly drop: number;\n}\n"],"names":["resolveSplatFoveationMode","mode","fallback","isPageTableFoveation","MAX_SH_BANDS","resolveSplatPerformanceProfile","explicit","profile","detectSplatDeviceProfile","isFillConstrainedSplatDevice"],"mappings":";AAoBO,SAASA,EACdC,GACAC,IAA+B,QACX;AACpB,SAAOD,KAAQC;AACjB;AAGO,SAASC,EAAqBF,GAAmC;AACtE,SAAOA,MAAS;AAClB;AAiCO,MAAMG,IAAe;AAQrB,SAASC,EACdC,GACAC,IAA0CC,KACjB;AACzB,SAAOF,MAAaG,EAA6BF,CAAO,IAAI,WAAW;AACzE;"}

package/dist/splat-mesh-types.d.ts

@@ -7,6 +7,12 @@ import type { SplatPool } from './splat-mesh-pool';
 import type { SplatShInputs, Vec3Uniform } from './splat-mesh-material';
 /** Construction-time projected-footprint policy selected by a streamed format. */
 export type ProjectedFilterProfile = 'default' | 'lcc';
+/** Canonical `.rad` foveation modes. */
+export type SplatFoveationMode = 'band' | 'frontier' | 'page-table';
+/** Resolve a caller-supplied foveation mode, defaulting when unset. */
+export declare function resolveSplatFoveationMode(mode: SplatFoveationMode | undefined, fallback?: SplatFoveationMode): SplatFoveationMode;
+/** True when the mode is the `.rad` page-table pager. */
+export declare function isPageTableFoveation(mode: string | undefined): boolean;
 /**
  * Opaque handle for a range of splats appended to a {@link SplatMesh},
  * used to remove the range again.
@@ -162,7 +168,7 @@ export interface SplatMeshOptions {
      *   too big and it is small enough (`parentPixelScale > limit ≥ ownPixelScale`),
      *   using per-splat `own_size`/`parent_size`. Full coverage by construction, no
      *   band leapfrogging. Baked into the material graph. See `docs/formats/rad-notes.md`.
-     * - `'pagetable'`: the {@link StreamedSplatMesh} default for `.rad` - a worker
+     * - `'page-table'`: the {@link StreamedSplatMesh} default for `.rad` - a worker
      *   owns the tree traversal and pages only the *selected* frontier into the
      *   pool (Spark's selected-index model), so the whole splat budget buys
      *   on-screen detail. Requires the streamed `.rad` machinery; on a plain
@@ -170,7 +176,7 @@ export interface SplatMeshOptions {
      *
      * @experimental `.rad` foveation option; may change in a minor release.
      */
-    foveationMode?: 'band' | 'frontier' | 'pagetable';
+    foveationMode?: SplatFoveationMode;
     /**
      * Target on-screen size (px) for the frontier / page-table cut: it keeps one
      * LOD level per view ray whose projected node size is about this. Larger =
@@ -219,9 +225,9 @@ export interface SplatMeshOptions {
      * cosmetic flip and renders in the data frame (raw Spark / mkkellogg parity);
      * LCC still self-orients (that is format semantics, not part of the switch).
      *
-     * For a static mesh the flip is chosen from {@link SplatData.sourceFormat}
-     * (stamped by the loaders); a dynamic-capacity mesh carries no format, so its
-     * host applies {@link yUpTransformForFormat} itself. See {@link SplatOrientation}.
+     * For a fully loaded mesh the flip is chosen from {@link SplatData.format}
+     * (stamped by the loaders); a dynamic-capacity mesh carries no format, so the
+     * caller applies {@link yUpTransformForFormat} itself. See {@link SplatOrientation}.
      */
     orientation?: SplatOrientation;
     /**
@@ -266,7 +272,7 @@ export interface SplatMeshOptions {
 export type SplatSortStrategy = 'counting' | 'radix' | 'exact';
 /** Controls optional work during a per-frame source update. */
 export interface SplatUpdateOptions {
-    /** Leave sorting to {@link UnifiedSplatRenderer}; uploads and LOD state still update. */
+    /** Leave sorting to {@link UnifiedSplatMesh}; uploads and LOD state still update. */
     sort?: boolean;
 }
 /**
@@ -303,8 +309,8 @@ export interface UnifiedSourceView {
     readonly modifiers: readonly SplatModifier[];
     /**
      * True when this source is itself a unified pool with per-source placement
-     * (`SplatScene`). The gather path cannot resolve nested placement, so
-     * `UnifiedSplatRenderer` rejects these sources.
+     * (`MergedSplatMesh`). The gather path cannot resolve nested placement, so
+     * `UnifiedSplatMesh` rejects these sources.
      */
     readonly hasSourcePlacement: boolean;
     readonly channels: ReadonlyMap<string, {

package/dist/splat-mesh.d.ts

@@ -133,7 +133,7 @@ export declare class SplatMesh extends THREE.Mesh implements SplatPoolTenant {
     /** Created on the first update, when the renderer backend is known. */
     private sorter;
     /**
-     * Set by a unified {@link SplatScene} subclass before the first sort: makes
+     * Set by a unified {@link MergedSplatMesh} subclass before the first sort: makes
      * the WebGPU sorter transform each splat's center to world space by its
      * source's matrix before measuring depth. `null` for an ordinary mesh, whose
      * sorter is byte-identical to before. See `source-transform.ts`.
@@ -376,7 +376,7 @@ export declare class SplatMesh extends THREE.Mesh implements SplatPoolTenant {
      */
     getUnifiedSourceView(): UnifiedSourceView;
     /**
-     * Marks this mesh as a source drawn by {@link UnifiedSplatRenderer}.
+     * Marks this mesh as a source drawn by {@link UnifiedSplatMesh}.
      * The source stays invisible to the regular scene draw, while its own picker
      * mirrors this resolved visibility so existing per-source hit testing works.
      * Internal consumers should clear the state with `null` before disposing.
@@ -384,7 +384,7 @@ export declare class SplatMesh extends THREE.Mesh implements SplatPoolTenant {
     setUnifiedPickVisibility(visible: boolean | null): void;
     /**
      * The visibility that actually decides whether this mesh's splats reach the
-     * screen: the owning {@link UnifiedSplatRenderer}'s per-source visibility
+     * screen: the owning {@link UnifiedSplatMesh}'s per-source visibility
      * while one owns the draw, else `Object3D.visible`. Consumers that gate on
      * "is this mesh showing" - the picker, `CameraBudgetGovernor` - must read
      * this rather than `visible`, which a unified renderer forces to `false` on
@@ -708,7 +708,7 @@ export declare class SplatMesh extends THREE.Mesh implements SplatPoolTenant {
     /**
      * Refreshes {@link boundingSphereLocal} - the sphere the sorter quantizes
      * depth over - when {@link boundsDirty}. The base mesh uses its local splat
-     * bounds; a unified {@link SplatScene} overrides this to supply a world-space
+     * bounds; a unified {@link MergedSplatMesh} overrides this to supply a world-space
      * bound spanning all its sources (whose transforms live in the shader).
      */
     protected refreshSortBounds(): void;

package/dist/splat-modifier.d.ts

@@ -9,7 +9,7 @@ export interface SplatContext {
     /**
      * Splat center in mesh-local space (pre-displacement).
      *
-     * Inside a `SplatScene` this is the splat's **placed** position
+     * Inside a `MergedSplatMesh` this is the splat's **placed** position
      * (`sourceMatrix · poolCenter`) - the placement is applied before the stack
      * runs, so effects stay anchored to the scene rather than travelling with a
      * moved source. Use {@link sourceCenter} for the pre-placement position.
@@ -17,14 +17,14 @@ export interface SplatContext {
     readonly localCenter: Node<'vec3'>;
     /**
      * The splat's position in its own source's data frame. Identical to
-     * {@link localCenter} on a plain mesh; inside a `SplatScene` it is the
+     * {@link localCenter} on a plain mesh; inside a `MergedSplatMesh` it is the
      * **pre-placement** position, for effects that should travel *with* a moved
      * source instead of staying put in the scene.
      */
     readonly sourceCenter: Node<'vec3'>;
     /**
      * Linear transform from the source data frame to mesh-local space. This is
-     * identity on a plain mesh; inside a {@link SplatScene} it is the linear part
+     * identity on a plain mesh; inside a {@link MergedSplatMesh} it is the linear part
      * of the source placement. Apply it to source-frame displacement vectors.
      * To express a source-frame rotation `R` as a mesh-local `rotation` output,
      * conjugate it: `sourceToLocal · R · sourceToLocal.inverse()`.
@@ -109,8 +109,8 @@ export interface ModifierStackTarget {
  *  - An **empty slot costs nothing**: it is omitted from the compacted list
  *    entirely, never compiled as a passthrough. All slots empty ⇒ the mesh
  *    gets an empty list ⇒ the unhooked graph (and the unified renderer's
- *    zero-modifier gather fast path stays eligible - except for a `SplatScene`,
- *    which `UnifiedSplatRenderer` does not accept as a source at all).
+ *    zero-modifier gather fast path stays eligible - except for a `MergedSplatMesh`,
+ *    which `UnifiedSplatMesh` does not accept as a source at all).
  *  - {@link apply} hands the mesh a **compacted array whose reference is
  *    stable** while the occupancy is unchanged, so re-applying after
  *    uniform-only changes is a guaranteed no-op on the mesh's identity diff -

package/dist/splat-partition.d.ts

@@ -6,7 +6,7 @@ import { type SelectionVolume } from './selection-volume';
  * transformed (and therefore independently animated) object.
  *
  * Both halves keep the source's local frame - separation does not bake any
- * transform. Register them as `SplatScene` or `UnifiedSplatRenderer` sources
+ * transform. Register them as `MergedSplatMesh` or `UnifiedSplatMesh` sources
  * for one global sort while they are posed independently. Separate
  * `SplatMesh` draw calls sort only within each mesh and can misblend where
  * their Gaussian footprints overlap.

package/dist/static-lod-entry.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

@@ -1,6 +1,6 @@
 /** @role Bridge - Camera-aware rendering for worker-built static splat hierarchies. */
 import * as THREE from 'three/webgpu';
-import { type SplatLoadOptions } from './load-scene';
+import { type SplatDataLoadOptions } from './load-splat-data';
 import { SplatMesh, type SplatMeshOptions, type SplatUpdateOptions } from './splat-mesh';
 import type { StaticLodBuildProgress } from './static-lod';
 export interface StaticLodSplatMeshOptions extends SplatMeshOptions {
@@ -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-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-aQdcWA6v.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