@voluma/vlam 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VOLUMA B.V.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,60 @@
+# VLAM!
+
+<!-- Image shields. Do not flatten CI badges to text links. -->
+
+[![CI](https://github.com/Voluma-ai/vlam/actions/workflows/ci.yml/badge.svg)](https://github.com/Voluma-ai/vlam/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/@voluma/vlam.svg)](https://www.npmjs.com/package/@voluma/vlam)
+[![demo](https://img.shields.io/badge/demo-live-4c1.svg)](https://vlam.voluma.ai)
+[![license](https://img.shields.io/github/license/Voluma-ai/vlam.svg)](./LICENSE)
+
+A WebGPU Gaussian Splat viewer for three.js.
+
+**Docs and demo:** [https://vlam.voluma.ai](https://vlam.voluma.ai) · [get started](site/get-started.md) · [guides](docs/guide/README.md)
+
+Local site and generated API: `npm run dev` (http://localhost:5170, viewer at `/demo/`).
+
+> Package `@voluma/vlam`, public **0.2.0**. APIs may still move before 1.0.
+
+## Install
+
+```bash
+npm install @voluma/vlam three
+```
+
+`three` is a peer dependency (`>= 0.185.0`).
+
+## Usage
+
+```ts
+import * as THREE from 'three/webgpu';
+import { SplatMesh, createSplatRenderer, loadScene } from '@voluma/vlam';
+
+const renderer = await createSplatRenderer();
+renderer.setSize(innerWidth, innerHeight);
+document.body.appendChild(renderer.domElement);
+
+const scene = new THREE.Scene();
+const camera = new THREE.PerspectiveCamera(60, innerWidth / innerHeight, 0.01, 100);
+camera.position.set(1, 0.5, 1.4);
+camera.lookAt(0, 0, 0);
+
+const splats = new SplatMesh(await loadScene('/scene.sog'));
+scene.add(splats);
+
+renderer.setAnimationLoop(() => {
+ splats.update(camera, renderer);
+ renderer.render(scene, camera);
+});
+```
+
+Formats: `.sog`, `.ply`, `.spz`, `.splat`, `.ksplat`, `.rad`. Large scenes: `StreamedSplatMesh`.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) and [docs/architecture.md](docs/architecture.md). By participating you agree to the [Code of Conduct](CODE_OF_CONDUCT.md). Security reports: see [SECURITY.md](SECURITY.md).
+
+## License
+
+[MIT](LICENSE). Third-party notices: [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).
+
+Made in the EU by [Voluma](https://voluma.ai).

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,86 @@
+# Third-party notices
+
+The published package bundles no third-party code as-is; [three](https://github.com/mrdoob/three.js)
+(MIT) is a peer dependency and is never included in the bundle. The notices
+below cover algorithms adapted, with substantial modification, into original
+source in this repository.
+
+## PlayCanvas Engine
+
+Copyright (c) 2011-2026 PlayCanvas Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+## Spark
+
+https://github.com/sparkjsdev/spark
+
+The `.rad`/`.radc` LOD tree traversal in `src/lib/formats/rad/` (notably the
+priority-frontier cut and its `new_compute_pixel_scale` foveation weighting)
+is a TypeScript port, with substantial modification, of Spark's Rust worker
+(`rust/spark-worker-rs/src/lod_tree.rs`).
+
+Copyright © 2025 WORLD LABS TECHNOLOGIES, INC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+## WebGPU-Radix-Sort
+
+https://github.com/kishimisu/WebGPU-Radix-Sort
+
+The stable ranked-scatter algorithm is based on WebGPU-Radix-Sort by
+kishimisu, declared MIT-licensed in its `package.json` (the repository ships
+no LICENSE file of its own; the notice below reproduces the standard MIT
+terms on the author's behalf).
+
+Copyright (c) kishimisu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/budget-governor.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Shared splat-budget governance across multiple streamed meshes.
+ *
+ * A single `StreamedSplatMesh` keeps itself within a per-device budget, but a
+ * host that shows several streamed scenes at once (a main capture plus marker
+ * or inset meshes) must not let each mesh claim the whole device budget -
+ * their pools are separate, so the costs add. Historically hosts hand-tuned
+ * this ("shrink the main mesh to 0.7 when markers exist"); the
+ * {@link BudgetGovernor} makes it a first-class policy: register each mesh
+ * with a priority weight and the governor splits one total budget across the
+ * members, reallocating when membership, weights, or the total change.
+ *
+ * The governor steers members exclusively through their public
+ * `setBudget`, so every downstream consumer of a member's budget - the
+ * flat-leaf `LodScheduler`, the LCC2 octree cut, and the RAD page-table draw
+ * target - sees the governed value through the exact path an explicit host
+ * `setBudget` call would take. Meshes never registered with a governor are
+ * completely unaffected.
+ */
+/**
+ * Anything the governor can steer. `StreamedSplatMesh` satisfies this
+ * structurally; a custom member only needs the same clamp-and-report
+ * `setBudget` contract.
+ */
+export interface BudgetGovernedMember {
+    /** The member's current effective active-splat budget. */
+    readonly budget: number;
+    /**
+     * Applies a budget and returns the value actually in effect - which may be
+     * lower than asked when the member clamps to a fixed ceiling (for
+     * `StreamedSplatMesh`, its `maxBudget`).
+     */
+    setBudget(budget: number): number;
+    /**
+     * The ceiling `setBudget` clamps to, when the member knows one
+     * (`StreamedSplatMesh.maxBudget`). **Advisory only** - allocation still
+     * discovers real caps from `setBudget`'s return value, so a member that
+     * omits this is governed exactly as well.
+     */
+    readonly maxBudget?: number;
+}
+/** Options for {@link BudgetGovernor}. */
+export interface BudgetGovernorOptions {
+    /**
+     * Total active-splat budget shared by all members. Defaults to the
+     * per-device {@link resolveSplatBudget} - i.e. the group as a whole gets
+     * what one mesh alone would get today.
+     */
+    totalBudget?: number;
+    /**
+     * Grow dead-band as a fraction of a member's current budget (default
+     * `0.1`). A reallocation that would *raise* a member's budget by no more
+     * than this fraction is skipped, so brief membership churn (a marker mesh
+     * appearing for a moment) does not thrash LOD schedules. Shrinks always
+     * apply immediately - that is what keeps `sum(member budgets) ≤ total` an
+     * invariant rather than a goal.
+     */
+    hysteresis?: number;
+}
+/**
+ * Splits one total splat budget across registered members by priority weight.
+ *
+ * Allocation is weighted and cap-aware: a member whose `setBudget` clamps
+ * below its weighted share (a small scene, or a mesh with a small pool)
+ * releases the difference to the remaining members, so the total is spent
+ * where it can buy detail. Reallocation runs automatically on
+ * register/unregister and on weight or total changes.
+ *
+ * A member at `weight: 0` is **suspended**: held at
+ * {@link SUSPENDED_BUDGET}, excluded from the weighted split, and its whole
+ * share released to the others - Spark's `lodScale: 0` hidden tier, without
+ * unregistering (so the mesh stays warm and re-weighting it costs nothing).
+ * Note that a suspended member is not *free*: its pool was allocated at
+ * construction and is never released, and a streamed mesh keeps its pinned
+ * coarse shell resident, so it consumes ≈0 of the budget rather than exactly 0.
+ * To give the memory back, dispose the mesh.
+ *
+ * For camera-driven weights - nearby meshes automatically taking a larger
+ * share - see `CameraBudgetGovernor`, which drives this class.
+ *
+ * Invariant: the sum of budgets the governor has applied to active members
+ * never exceeds {@link totalBudget}.
+ */
+export declare class BudgetGovernor {
+    private readonly entries;
+    private total;
+    private readonly hysteresis;
+    constructor(options?: BudgetGovernorOptions);
+    /** The shared budget currently being split across members. */
+    get totalBudget(): number;
+    /** Replaces the shared total and reallocates. */
+    setTotalBudget(totalBudget: number): void;
+    /** Number of registered members. */
+    get size(): number;
+    /**
+     * Adds a member and reallocates the shared budget. The member's current
+     * budget is remembered and restored when it leaves the governor.
+     *
+     * @param member - The mesh (or compatible object) to govern.
+     * @param options - `weight` (default `1`): the member's share is
+     * proportional to its weight - e.g. main mesh `7`, marker `3` reproduces
+     * the old 0.7 host split. `0` registers the member suspended.
+     */
+    register(member: BudgetGovernedMember, options?: {
+        weight?: number;
+    }): void;
+    /**
+     * Removes a member, restores the budget it had when it registered, and
+     * reallocates the total across the remaining members. No-op for a member
+     * that is not registered (so disposing hosts need not track membership).
+     */
+    unregister(member: BudgetGovernedMember): void;
+    /**
+     * Changes a member's priority weight and reallocates. `0` suspends the
+     * member (see the class doc); any positive weight resumes it.
+     */
+    setWeight(member: BudgetGovernedMember, weight: number): void;
+    /**
+     * Writes several weights, then reallocates **once**.
+     *
+     * Prefer this to a loop of {@link setWeight} whenever more than one weight
+     * changes together - as a camera-driven reweight does. Each reallocation
+     * pushes `setBudget` to every member, and for a streamed mesh that forces an
+     * LOD reschedule, so N separate calls cost N passes over the whole group to
+     * reach a state one pass would have produced.
+     *
+     * @param weights - `[member, weight]` pairs. Every member must be registered;
+     * unlisted members keep their current weight.
+     * @throws {Error} if any member is not registered - checked before anything
+     * is written, so a bad pair leaves every weight untouched.
+     * @throws {RangeError} if any weight is not a non-negative finite number.
+     */
+    setWeights(weights: Iterable<readonly [BudgetGovernedMember, number]>): void;
+    /** The budget the governor last applied to a member, if registered. */
+    budgetOf(member: BudgetGovernedMember): number | undefined;
+    /**
+     * Recomputes and applies every member's share. Called automatically by all
+     * mutators; call it manually only if a member's internal ceiling changed
+     * outside the governor's view.
+     */
+    reallocate(): void;
+    /**
+     * Restores every member's pre-registration budget and empties the governor.
+     * The governor itself stays usable (dispose is just "unregister everyone").
+     */
+    dispose(): void;
+    /** The entry for a registered member, or a thrown error naming the problem. */
+    private entryOf;
+    /**
+     * Pushes `target` to a member, with the grow dead-band. Returns true when
+     * the member clamped below its target (it is capped and cannot absorb more).
+     */
+    private applyTarget;
+}

package/dist/camera-budget-governor.d.ts

@@ -0,0 +1,234 @@
+/**
+ * Camera-driven splat-budget weighting across several streamed meshes.
+ *
+ * {@link BudgetGovernor} splits one total by *priority*, which a host must
+ * choose and maintain. That is the wrong axis for a scene of markers: what
+ * makes a marker worth splats is that the camera is near it, and that changes
+ * every frame. Splitting a pool evenly instead (`pool / N`) gives the marker
+ * you fly up to a quarter of the budget it needs while three markers nobody is
+ * looking at hold the rest.
+ *
+ * {@link CameraBudgetGovernor} closes that loop: each update it measures every
+ * member's projected size from the camera, multiplies in the host's priority
+ * tier, and writes the resulting weights to a `BudgetGovernor` in one batch.
+ * Approaching one of four markers pulls budget off the far ones automatically.
+ *
+ * This is Spark's model, reached differently. Spark shares one `lodSplatCount`
+ * and biases meshes with a per-mesh `lodScale` (focused 2, adjacent 0.25,
+ * hidden 0); its GPU traversal then favors near, on-screen detail on its own.
+ * VLAM's meshes each own a pool, so the near/far bias has to be applied to the
+ * *budget* - which is what this class does, with `priority` playing the part of
+ * `lodScale`. (For a `.rad` page-table mesh, `StreamedSplatMesh.lodScale` is
+ * also available and is Spark's knob exactly.)
+ *
+ * Composition, not inheritance: `BudgetGovernor` stays a pure allocation
+ * policy with no camera and no frame lifecycle, and a host that wants fixed
+ * weights keeps using it directly.
+ */
+import * as THREE from 'three/webgpu';
+import { BudgetGovernor, type BudgetGovernedMember, type BudgetGovernorOptions } from './budget-governor';
+/**
+ * A governed member this class can measure. Every `SplatMesh` (and so every
+ * `StreamedSplatMesh`) satisfies it structurally - there is no extra host
+ * plumbing to write.
+ */
+export interface CameraBudgetMember extends BudgetGovernedMember {
+    /**
+     * The member's splat bounds in its own local frame. `StreamedSplatMesh`
+     * overrides this to the whole scene's bounds, which are known from the
+     * manifest - so weighting is correct from the first frame, before a single
+     * chunk has loaded.
+     */
+    computeSplatBounds(): THREE.Box3;
+    /** Local→world transform, read after {@link updateWorldMatrix}. */
+    readonly matrixWorld: THREE.Matrix4;
+    /** `Object3D.updateWorldMatrix`; called so a fresh member is placed correctly. */
+    updateWorldMatrix(updateParents: boolean, updateChildren: boolean): void;
+    /**
+     * `Object3D.visible`. A hidden member is suspended (weight 0) - it draws
+     * nothing, so it should hold no budget. This is the member's own flag, not an
+     * ancestor walk: a host hiding a whole group should set `priority: 0`.
+     */
+    readonly visible: boolean;
+    /**
+     * The visibility that actually decides whether the member's splats reach the
+     * screen, when that differs from `visible`. `SplatMesh` provides it: a
+     * `UnifiedSplatRenderer` forces `visible = false` on every source it owns
+     * (only to keep the regular scene draw from double-drawing them) while the
+     * source may be fully on screen through the unified draw - without this, the
+     * governor would suspend every unified source and freeze its streaming.
+     * When present it wins over `visible`.
+     */
+    readonly effectiveVisibility?: boolean;
+}
+/** Options for {@link CameraBudgetGovernor}. */
+export interface CameraBudgetGovernorOptions extends BudgetGovernorOptions {
+    /**
+     * An existing governor to drive, when the host already has one (or wants to
+     * mix camera-weighted and fixed-weight members). By default one is built
+     * from the inherited {@link BudgetGovernorOptions}.
+     */
+    governor?: BudgetGovernor;
+    /**
+     * Minimum milliseconds between reweights. Default `250`, matching
+     * `StreamedSplatMesh`'s own idle reschedule interval: a mesh cannot act on a
+     * budget change faster than it reschedules, so reweighting more often buys
+     * nothing and costs a forced reschedule on every member. Membership and
+     * priority changes bypass it.
+     */
+    minIntervalMs?: number;
+    /**
+     * Relative weight change below which a reweight is skipped entirely, as a
+     * fraction of the weight in effect. Default `0.15`.
+     *
+     * This sits *above* `BudgetGovernor`'s grow dead-band and does a different
+     * job: that one damps budget churn on a member, this one suppresses the
+     * reallocation altogether so an idling camera does no work at all.
+     */
+    weightDeadband?: number;
+    /**
+     * Exponent on projected size. `1` (default) weights by angular size -
+     * halving the distance doubles the share. `2` weights by projected *area*,
+     * which concentrates the budget harder on the nearest member.
+     */
+    falloff?: number;
+    /**
+     * Weight multiplier for a member outside the view frustum. Default `0.25`:
+     * suppressed, never starved. Off-screen members must keep enough budget for
+     * their coarse shell, or turning the camera exposes an unpainted region -
+     * the same foveate-don't-cull policy the `.rad` frontier traversal follows.
+     */
+    offScreenWeight?: number;
+    /** Floor on the projected-size term, so a very distant member still holds a
+     * coarse shell. Default `0.05`. */
+    minWeight?: number;
+    /** Ceiling on the projected-size term, so a member the camera is inside
+     * cannot take the entire total. Default `8`. */
+    maxWeight?: number;
+}
+/** Per-member options for {@link CameraBudgetGovernor.register}. */
+export interface CameraBudgetMemberOptions {
+    /**
+     * Host priority multiplied into the camera term - Spark's `lodScale` tiers:
+     * focused `2`, default `1`, adjacent `0.25`, hidden `0`. Default `1`.
+     * `0` suspends the member (see {@link BudgetGovernor}).
+     */
+    priority?: number;
+    /**
+     * Pins this member's weight, opting it out of camera weighting while it still
+     * competes for the same total. Use it for a main scene that should hold a
+     * steady share while markers fight over the rest - e.g. `fixedWeight: 4`
+     * against markers averaging `1`.
+     */
+    fixedWeight?: number;
+}
+/**
+ * Weights a {@link BudgetGovernor}'s members by how large each one projects
+ * from the camera, so nearby meshes take budget from distant ones.
+ *
+ * ```js
+ * const governor = new CameraBudgetGovernor({ totalBudget: 4_000_000 });
+ * governor.register(main, { fixedWeight: 4 }); // steady share
+ * governor.register(markerA); // camera-weighted, priority 1
+ * governor.register(markerB);
+ *
+ * // once per frame, after the scene graph is up to date:
+ * governor.update(camera);
+ * ```
+ *
+ * Every guarantee of the underlying governor still holds - most importantly
+ * that the applied budgets never sum above the total, and that unregistering a
+ * member restores the budget it had when it joined.
+ *
+ * **A member can only grow into a budget its pool can hold.** A streamed mesh
+ * allocates its pool once, from its construction budget, and clamps `setBudget`
+ * to it - so a marker built at a quarter of the total can never be given more
+ * than a quarter, however close the camera gets. Construct governed meshes with
+ * `maxBudget` set to the largest share they should ever reach, and price those
+ * ceilings with `estimateSplatPoolBytes` first: the pools cost their ceilings
+ * whatever the budget is split to.
+ */
+export declare class CameraBudgetGovernor {
+    private readonly entries;
+    private readonly budgetGovernor;
+    private readonly minIntervalMs;
+    private readonly weightDeadband;
+    private readonly falloff;
+    private readonly offScreenWeight;
+    private readonly minWeight;
+    private readonly maxWeight;
+    private lastUpdateAt;
+    /** Set by membership/priority changes: the next update ignores both damps. */
+    private forceNext;
+    constructor(options?: CameraBudgetGovernorOptions);
+    /** The governor this drives; use it for fixed-weight members and diagnostics. */
+    get governor(): BudgetGovernor;
+    /** The shared total being split, from the underlying governor. */
+    get totalBudget(): number;
+    /** Replaces the shared total (e.g. the presenting budget on `sessionstart`). */
+    setTotalBudget(totalBudget: number): void;
+    /** Number of camera-weighted members. */
+    get size(): number;
+    /**
+     * Adds a member, registers it with the underlying governor, and forces a
+     * reweight on the next {@link update}.
+     *
+     * @throws {Error} if the member is already registered here.
+     * @throws {RangeError} if `priority` or `fixedWeight` is invalid.
+     */
+    register(member: CameraBudgetMember, options?: CameraBudgetMemberOptions): void;
+    /**
+     * Removes a member from this helper and the underlying governor, restoring
+     * the budget it had when it joined. No-op for an unknown member.
+     */
+    unregister(member: CameraBudgetMember): void;
+    /**
+     * Changes a member's priority tier. Takes effect on the next {@link update},
+     * which is forced - a deliberate focus change should not wait out the
+     * interval or be swallowed by the dead-band.
+     *
+     * @throws {Error} if the member is not registered here.
+     * @throws {RangeError} if `priority` is negative or not finite.
+     */
+    setPriority(member: CameraBudgetMember, priority: number): void;
+    /**
+     * Recomputes every member's weight from the camera and applies them in one
+     * batch. Call once per frame, after the scene graph is up to date.
+     *
+     * Needs no renderer: weights are a ratio, so viewport size cancels out.
+     *
+     * Skipped - returning `false` - when called inside `minIntervalMs` of the
+     * last reweight, or when no member's weight moved by more than
+     * `weightDeadband`. Membership and priority changes force it through both.
+     *
+     * @param camera - The view detail should follow. In an immersive session pass
+     * the head/`ArrayCamera`, not the idle application camera.
+     * @param now - Timestamp in ms on the `performance.now` clock; defaults to it.
+     * @returns whether weights were reapplied.
+     */
+    update(camera: THREE.Camera, now?: number): boolean;
+    /** The weight currently written for a member, if registered here. */
+    weightOf(member: CameraBudgetMember): number | undefined;
+    /** The budget the underlying governor last applied to a member. */
+    budgetOf(member: CameraBudgetMember): number | undefined;
+    /**
+     * Unregisters every member, restoring the budget each had when it joined.
+     * The helper stays usable afterwards. A governor passed in by the host keeps
+     * any members the host registered on it directly.
+     */
+    dispose(): void;
+    /**
+     * A member's weight: `priority × clamp((radius / distance) ^ falloff) ×
+     * offScreen`.
+     *
+     * `radius / distance` is the tangent of the member's half angular size - the
+     * same `size / distance` measure Spark's `pixel_scale` traversal ranks nodes
+     * by, one level up at whole-mesh granularity. Distance is measured to the
+     * bounding sphere's *surface*, so a large mesh is not penalized for having a
+     * distant center, and is floored so a camera inside the bounds saturates at
+     * `maxWeight` rather than dividing by zero.
+     */
+    private weightFor;
+    /** Whether a weight moved enough to be worth a reallocation. */
+    private isSignificant;
+}