gaussian-splat-lite 1.3.0 → 1.3.2

package/dist/types/loaders/stream/rad-stream/RadStreamScheduler.d.ts

@@ -3,8 +3,16 @@ import type { StreamResolutionSource } from "../StreamCameras.js";
 import type { StreamSchedulerOptions, StreamStats } from "../streamOptions.js";
 import type { RadStreamLoaderOptions } from "./RadStreamLoader.js";
 export type RadStreamSchedulerOptions = RadStreamLoaderOptions &
-  StreamSchedulerOptions;
+  StreamSchedulerOptions & {
+    /** Allowed fractional splat budget overshoot. Default: 0.1; 0 forbids overshoot. */
+    splatBudgetTolerance?: number;
+    /** Retained CPU byte budget, excluding pending copies and WASM. Default: 2 GiB. */
+    maxResidentCpuBytes?: number;
+    /** Estimated GPU byte budget for resident streaming data. Default: 1 GiB. */
+    maxResidentGpuBytes?: number;
+  };
 export type RadStreamStats = StreamStats & {
+  /** Resident page limit derived from the smaller CPU/GPU allowance. */
   pageBudget: number;
   lodTimeMs: number;
 };
@@ -17,7 +25,10 @@ export declare class RadStreamScheduler {
   readonly cooldownMs: number;
   readonly fadeDurationMs: number;
   readonly maxConcurrentLoads: number;
+  readonly maxResidentCpuBytes: number;
+  readonly maxResidentGpuBytes: number;
   private _splatBudget;
+  private _splatBudgetTolerance;
   private readonly loader;
   private readonly abort;
   private readonly streamCameras;
@@ -46,9 +57,12 @@ export declare class RadStreamScheduler {
   private resolveFirst;
   private rejectFirst;
   constructor(options: RadStreamSchedulerOptions);
-  /** Selected-node budget. Assigning a new value requests LOD selection. */
+  /** Target selected-node budget. Assigning a new value requests LOD selection. */
   get splatBudget(): number;
   set splatBudget(value: number);
+  /** Allowed fractional budget overshoot; zero forbids overshoot. */
+  get splatBudgetTolerance(): number;
+  set splatBudgetTolerance(value: number);
   /** Cameras that select detail, in registration order. */
   get cameras(): readonly THREE.Camera[];
   hasCamera(camera: THREE.Camera): boolean;
@@ -84,6 +98,7 @@ export declare class RadStreamScheduler {
    * detail any of them needs.
    */
   update(): boolean;
+  private get selectionBaselineId();
   private requestSelection;
   private selectionPagesReady;
   private prepareSelection;
@@ -102,6 +117,7 @@ export declare class RadStreamScheduler {
   private reservePages;
   private uploadPages;
   private releasePage;
+  private isPageRequired;
   private releaseUnused;
   /** Map a raycast hit's rendered index back to its stable file index. */
   getGlobalIndex(mesh: THREE.Object3D, renderedIndex: number): number;

package/dist/types/loaders/stream/rad-stream/RadStreamWorker.d.cts

@@ -1,6 +1,6 @@
 import { WorkerRpc } from "../../../runtime/WorkerRpc.cjs";
 import type { RadStreamRpcHandlers } from "./worker.cjs";
-/** Worker assigned either LOD ownership or a persistent page decoder. */
+/** Worker assigned traversal, display preparation, or page decoding. */
 export declare class RadStreamWorker extends WorkerRpc<RadStreamRpcHandlers> {
   constructor(onDispose?: () => void);
 }

package/dist/types/loaders/stream/rad-stream/RadStreamWorker.d.ts

@@ -1,6 +1,6 @@
 import { WorkerRpc } from "../../../runtime/WorkerRpc.js";
 import type { RadStreamRpcHandlers } from "./worker.js";
-/** Worker assigned either LOD ownership or a persistent page decoder. */
+/** Worker assigned traversal, display preparation, or page decoding. */
 export declare class RadStreamWorker extends WorkerRpc<RadStreamRpcHandlers> {
   constructor(onDispose?: () => void);
 }

package/dist/types/loaders/stream/rad-stream/prepareRadSelection.d.cts

@@ -8,25 +8,16 @@ export type RadSelectionChunk = Pick<
   RadLodChunk,
   "sourceToStorage" | "boundsBlocks"
 >;
+export type RadSelectionPreparation = {
+  selection: Omit<RadStreamSelection, "fade">;
+  fade: boolean;
+  pools: RadPreparedSelection[];
+};
 /** The scheduler snapshots and pins resident pages before dispatching this work. */
 export declare function prepareRadSelection(
-  {
-    selection,
-    pools,
-  }: {
+  request: {
     selection: RadStreamSelection;
     pools: RadSelectionSnapshot[];
   },
   chunks: ReadonlyMap<number, RadSelectionChunk>,
-): {
-  selection: {
-    indices: Uint32Array;
-    wantedChunks: Uint32Array;
-    touchedChunks: Uint32Array;
-    selectionId: number;
-    changedChunks: Uint32Array;
-  };
-  fade: boolean;
-  pools: RadPreparedSelection[];
-};
-export type RadSelectionPreparation = ReturnType<typeof prepareRadSelection>;
+): RadSelectionPreparation;

package/dist/types/loaders/stream/rad-stream/prepareRadSelection.d.ts

@@ -8,25 +8,16 @@ export type RadSelectionChunk = Pick<
   RadLodChunk,
   "sourceToStorage" | "boundsBlocks"
 >;
+export type RadSelectionPreparation = {
+  selection: Omit<RadStreamSelection, "fade">;
+  fade: boolean;
+  pools: RadPreparedSelection[];
+};
 /** The scheduler snapshots and pins resident pages before dispatching this work. */
 export declare function prepareRadSelection(
-  {
-    selection,
-    pools,
-  }: {
+  request: {
     selection: RadStreamSelection;
     pools: RadSelectionSnapshot[];
   },
   chunks: ReadonlyMap<number, RadSelectionChunk>,
-): {
-  selection: {
-    indices: Uint32Array;
-    wantedChunks: Uint32Array;
-    touchedChunks: Uint32Array;
-    selectionId: number;
-    changedChunks: Uint32Array;
-  };
-  fade: boolean;
-  pools: RadPreparedSelection[];
-};
-export type RadSelectionPreparation = ReturnType<typeof prepareRadSelection>;
+): RadSelectionPreparation;

package/dist/types/loaders/stream/rad-stream/radLod.d.cts

@@ -1,5 +1,5 @@
 import type { RadMeta } from "../../rad/radFormat.cjs";
-/** CPU-only data retained in the dataset worker, never GPU source storage. */
+/** CPU-only page data split between traversal and display preparation workers. */
 export type RadLodChunk = {
   centers: Float32Array;
   radii: Float32Array;
@@ -22,9 +22,11 @@ export type RadLodView = {
 export type RadLodRequest = {
   views: RadLodView[];
   splatBudget: number;
+  splatBudgetTolerance: number;
+  /** Combined limit for resident tree paths and requested pages. */
+  pageBudget: number;
   pixelThreshold: number;
   residentChunks: number[];
-  hysteresis?: number;
 };
 export type RadLodSelection = {
   /** Stable file indices. The scheduler maps these to occupied GPU slots. */

package/dist/types/loaders/stream/rad-stream/radLod.d.ts

@@ -1,5 +1,5 @@
 import type { RadMeta } from "../../rad/radFormat.js";
-/** CPU-only data retained in the dataset worker, never GPU source storage. */
+/** CPU-only page data split between traversal and display preparation workers. */
 export type RadLodChunk = {
   centers: Float32Array;
   radii: Float32Array;
@@ -22,9 +22,11 @@ export type RadLodView = {
 export type RadLodRequest = {
   views: RadLodView[];
   splatBudget: number;
+  splatBudgetTolerance: number;
+  /** Combined limit for resident tree paths and requested pages. */
+  pageBudget: number;
   pixelThreshold: number;
   residentChunks: number[];
-  hysteresis?: number;
 };
 export type RadLodSelection = {
   /** Stable file indices. The scheduler maps these to occupied GPU slots. */

package/dist/types/loaders/stream/rad-stream/workerHandlers.d.cts

@@ -1,89 +1,60 @@
-import type { RadReadRequest } from "../../rad/RadSource.cjs";
-import type { RadHeader } from "../../rad/radFormat.cjs";
+import type { RadReadRequest, RadResourceState } from "../../rad/RadSource.cjs";
+import type { RadHeader, RadStreamChunk } from "../../rad/radFormat.cjs";
 import type {
   RadSelectionReply,
   RadSelectionRequest,
 } from "./RadSelectionState.cjs";
-import type { prepareRadSelection } from "./prepareRadSelection.cjs";
+import type {
+  RadSelectionChunk,
+  RadSelectionPreparation,
+  prepareRadSelection,
+} from "./prepareRadSelection.cjs";
 import type { RadLodChunk } from "./radLod.cjs";
-/** Each worker initializes once as either the dataset LOD tree or a page decoder. */
+/** Workers own LOD traversal, display preparation, or a persistent page decoder. */
 export declare function createRadStreamHandlers(): {
-  prepareRadSelection(request: Parameters<typeof prepareRadSelection>[0]): {
-    selection: {
-      indices: Uint32Array;
-      wantedChunks: Uint32Array;
-      touchedChunks: Uint32Array;
-      selectionId: number;
-      changedChunks: Uint32Array;
-    };
-    fade: boolean;
-    pools: import("../../../data/RadPagedSplats.cjs").RadPreparedSelection[];
-  };
-  initializeRad({
-    bytes,
-  }: {
-    bytes: Uint8Array;
-  }): RadHeader;
-  initializeRadDecoder({
-    header: value,
-    rootBytes,
-  }: {
+  prepareRadSelection(
+    request: Parameters<typeof prepareRadSelection>[0],
+  ): RadSelectionPreparation;
+  initializeRad(request: { bytes: Uint8Array }): RadHeader;
+  initializeRadDecoder(request: {
     header: RadHeader;
     rootBytes?: Uint8Array;
   }): void;
   loadRadChunk(
-    {
-      index,
-      generation,
-      request,
-    }: {
+    args: {
       index: number;
       generation: number;
       request: RadReadRequest;
     },
-    {
-      sendStatus,
-    }: {
+    options: {
       sendStatus: (data: {
         loaded: number;
       }) => void;
     },
   ): Promise<{
-    data: {
-      numSplats: number;
-      splatArrays: [Uint32Array<ArrayBufferLike>, Uint32Array<ArrayBufferLike>];
-      extra: import("../../../data/defines.cjs").SplatExtra;
-      rootRadius: number | undefined;
-    } & import("../../../data/defines.cjs").SplatResult & {
-        sourceIds: Uint32Array;
-        centerOnlyBoundingBox: Float32Array;
-        boundingBox: Float32Array;
-        spatialBounds: Float32Array;
-      };
+    data: RadStreamChunk;
     tree: RadLodChunk;
-    state: import("../../rad/RadSource.cjs").RadResourceState | undefined;
+    state: RadResourceState | undefined;
     rootBytes: Uint8Array<ArrayBufferLike> | undefined;
   }>;
-  cancelRadLoad({
-    generation,
-  }: {
+  cancelRadLoad(request: { generation: number }): void;
+  retainRadChunk(request: {
+    index: number;
     generation: number;
+    tree: Omit<RadLodChunk, keyof RadSelectionChunk>;
   }): void;
-  retainRadChunk({
-    index,
-    generation,
-    tree,
-  }: {
+  retainRadSelectionChunk(request: {
     index: number;
     generation: number;
-    tree: RadLodChunk;
-  }): void;
+    chunk: RadSelectionChunk;
+  }): number;
   selectRadLod(request: RadSelectionRequest): RadSelectionReply;
-  releaseRadChunk({
-    index,
-    generation,
-  }: {
+  releaseRadChunk(request: {
     index: number;
     generation?: number;
   }): void;
+  releaseRadSelectionChunk(request: {
+    index: number;
+    generation?: number;
+  }): number;
 };

package/dist/types/loaders/stream/rad-stream/workerHandlers.d.ts

@@ -1,89 +1,60 @@
-import type { RadReadRequest } from "../../rad/RadSource.js";
-import type { RadHeader } from "../../rad/radFormat.js";
+import type { RadReadRequest, RadResourceState } from "../../rad/RadSource.js";
+import type { RadHeader, RadStreamChunk } from "../../rad/radFormat.js";
 import type {
   RadSelectionReply,
   RadSelectionRequest,
 } from "./RadSelectionState.js";
-import type { prepareRadSelection } from "./prepareRadSelection.js";
+import type {
+  RadSelectionChunk,
+  RadSelectionPreparation,
+  prepareRadSelection,
+} from "./prepareRadSelection.js";
 import type { RadLodChunk } from "./radLod.js";
-/** Each worker initializes once as either the dataset LOD tree or a page decoder. */
+/** Workers own LOD traversal, display preparation, or a persistent page decoder. */
 export declare function createRadStreamHandlers(): {
-  prepareRadSelection(request: Parameters<typeof prepareRadSelection>[0]): {
-    selection: {
-      indices: Uint32Array;
-      wantedChunks: Uint32Array;
-      touchedChunks: Uint32Array;
-      selectionId: number;
-      changedChunks: Uint32Array;
-    };
-    fade: boolean;
-    pools: import("../../../data/RadPagedSplats.js").RadPreparedSelection[];
-  };
-  initializeRad({
-    bytes,
-  }: {
-    bytes: Uint8Array;
-  }): RadHeader;
-  initializeRadDecoder({
-    header: value,
-    rootBytes,
-  }: {
+  prepareRadSelection(
+    request: Parameters<typeof prepareRadSelection>[0],
+  ): RadSelectionPreparation;
+  initializeRad(request: { bytes: Uint8Array }): RadHeader;
+  initializeRadDecoder(request: {
     header: RadHeader;
     rootBytes?: Uint8Array;
   }): void;
   loadRadChunk(
-    {
-      index,
-      generation,
-      request,
-    }: {
+    args: {
       index: number;
       generation: number;
       request: RadReadRequest;
     },
-    {
-      sendStatus,
-    }: {
+    options: {
       sendStatus: (data: {
         loaded: number;
       }) => void;
     },
   ): Promise<{
-    data: {
-      numSplats: number;
-      splatArrays: [Uint32Array<ArrayBufferLike>, Uint32Array<ArrayBufferLike>];
-      extra: import("../../../data/defines.js").SplatExtra;
-      rootRadius: number | undefined;
-    } & import("../../../data/defines.js").SplatResult & {
-        sourceIds: Uint32Array;
-        centerOnlyBoundingBox: Float32Array;
-        boundingBox: Float32Array;
-        spatialBounds: Float32Array;
-      };
+    data: RadStreamChunk;
     tree: RadLodChunk;
-    state: import("../../rad/RadSource.js").RadResourceState | undefined;
+    state: RadResourceState | undefined;
     rootBytes: Uint8Array<ArrayBufferLike> | undefined;
   }>;
-  cancelRadLoad({
-    generation,
-  }: {
+  cancelRadLoad(request: { generation: number }): void;
+  retainRadChunk(request: {
+    index: number;
     generation: number;
+    tree: Omit<RadLodChunk, keyof RadSelectionChunk>;
   }): void;
-  retainRadChunk({
-    index,
-    generation,
-    tree,
-  }: {
+  retainRadSelectionChunk(request: {
     index: number;
     generation: number;
-    tree: RadLodChunk;
-  }): void;
+    chunk: RadSelectionChunk;
+  }): number;
   selectRadLod(request: RadSelectionRequest): RadSelectionReply;
-  releaseRadChunk({
-    index,
-    generation,
-  }: {
+  releaseRadChunk(request: {
     index: number;
     generation?: number;
   }): void;
+  releaseRadSelectionChunk(request: {
+    index: number;
+    generation?: number;
+  }): number;
 };

package/dist/types/loaders/stream/sog-stream/SogStreamBatch.d.cts

@@ -14,7 +14,6 @@ export declare class SogStreamBatch extends SplatMesh {
     group: THREE.Group,
     onEmpty: () => void,
   );
-  get residentBytes(): number;
   writeRegion(start: number, data: ReorderedSplatResult): void;
   setRegionOpacity(start: number, opacity: number): void;
   releaseRegion(start: number): void;

package/dist/types/loaders/stream/sog-stream/SogStreamBatch.d.ts

@@ -14,7 +14,6 @@ export declare class SogStreamBatch extends SplatMesh {
     group: THREE.Group,
     onEmpty: () => void,
   );
-  get residentBytes(): number;
   writeRegion(start: number, data: ReorderedSplatResult): void;
   setRegionOpacity(start: number, opacity: number): void;
   releaseRegion(start: number): void;

package/dist/types/loaders/stream/sog-stream/SogStreamLoader.d.cts

@@ -2,7 +2,7 @@ import type { Splats } from "../../../data/Splats.cjs";
 import type { StreamRequestOptions } from "../streamOptions.cjs";
 import type { SogStreamWorker } from "./SogStreamWorker.cjs";
 import type { SogLodMetadata } from "./sogLod.cjs";
-import type { SogView } from "./sogVisibility.cjs";
+import type { SogLodRequest } from "./sogVisibility.cjs";
 import type { SogChunkInfo } from "./workerHandlers.cjs";
 export type SogStreamLoaderOptions = StreamRequestOptions & {
   url: string;
@@ -54,7 +54,7 @@ export declare class SogStreamLoader {
   private assertActive;
   initialize(signal?: AbortSignal): Promise<SogLodMetadata>;
   private readIndex;
-  selectLod(view: SogView, budget: number): Promise<Uint32Array>;
+  selectLod(request: SogLodRequest): Promise<Uint32Array>;
   load(
     url: string,
     count: number,

package/dist/types/loaders/stream/sog-stream/SogStreamLoader.d.ts

@@ -2,7 +2,7 @@ import type { Splats } from "../../../data/Splats.js";
 import type { StreamRequestOptions } from "../streamOptions.js";
 import type { SogStreamWorker } from "./SogStreamWorker.js";
 import type { SogLodMetadata } from "./sogLod.js";
-import type { SogView } from "./sogVisibility.js";
+import type { SogLodRequest } from "./sogVisibility.js";
 import type { SogChunkInfo } from "./workerHandlers.js";
 export type SogStreamLoaderOptions = StreamRequestOptions & {
   url: string;
@@ -54,7 +54,7 @@ export declare class SogStreamLoader {
   private assertActive;
   initialize(signal?: AbortSignal): Promise<SogLodMetadata>;
   private readIndex;
-  selectLod(view: SogView, budget: number): Promise<Uint32Array>;
+  selectLod(request: SogLodRequest): Promise<Uint32Array>;
   load(
     url: string,
     count: number,

package/dist/types/loaders/stream/sog-stream/SogStreamScheduler.d.cts

@@ -1,8 +1,16 @@
 import type * as THREE from "three";
 import type { StreamSchedulerOptions, StreamStats } from "../streamOptions.cjs";
 import type { SogStreamLoaderOptions } from "./SogStreamLoader.cjs";
+import type { SogBudgetMode } from "./sogLod.cjs";
 export type SogStreamSchedulerOptions = SogStreamLoaderOptions &
-  StreamSchedulerOptions;
+  StreamSchedulerOptions & {
+    /** Defaults to "target". "limit" caps detail at the configured distance bands. */
+    splatBudgetMode?: SogBudgetMode;
+    /** Base LOD distance in world units for "limit" mode; defaults to 100. Must be finite and positive. */
+    lodBaseDistance?: number;
+    /** Distance multiplier between LOD levels in both modes; defaults to 2. Must be finite and at least 1. */
+    lodMultiplier?: number;
+  };
 export type SogStreamStats = StreamStats & {
   visibleRegions: number;
 };
@@ -15,6 +23,9 @@ export declare class SogStreamScheduler {
   readonly fadeDurationMs: number;
   readonly maxConcurrentLoads: number;
   private _splatBudget;
+  private _splatBudgetMode;
+  private _lodBaseDistance;
+  private _lodMultiplier;
   private readonly options;
   private readonly loader;
   private readonly abort;
@@ -37,9 +48,18 @@ export declare class SogStreamScheduler {
   private resolveFirst;
   private rejectFirst;
   constructor(options: SogStreamSchedulerOptions);
-  /** Visible-point target, including the environment. Reassign to reselect LODs. */
+  /** Visible-point budget, including the environment. Reassign to reselect LODs. */
   get splatBudget(): number;
   set splatBudget(value: number);
+  /** Fill the budget, or limit detail to the configured distance bands. */
+  get splatBudgetMode(): SogBudgetMode;
+  set splatBudgetMode(value: SogBudgetMode);
+  /** Base LOD distance in world units for limit mode. Higher retains more detail. */
+  get lodBaseDistance(): number;
+  set lodBaseDistance(value: number);
+  /** Distance multiplier between LOD levels; affects both budget modes. */
+  get lodMultiplier(): number;
+  set lodMultiplier(value: number);
   get stats(): SogStreamStats;
   /** Group-local bounds from the index; available after initialized resolves. */
   getBoundingBox(): THREE.Box3;

package/dist/types/loaders/stream/sog-stream/SogStreamScheduler.d.ts

@@ -1,8 +1,16 @@
 import type * as THREE from "three";
 import type { StreamSchedulerOptions, StreamStats } from "../streamOptions.js";
 import type { SogStreamLoaderOptions } from "./SogStreamLoader.js";
+import type { SogBudgetMode } from "./sogLod.js";
 export type SogStreamSchedulerOptions = SogStreamLoaderOptions &
-  StreamSchedulerOptions;
+  StreamSchedulerOptions & {
+    /** Defaults to "target". "limit" caps detail at the configured distance bands. */
+    splatBudgetMode?: SogBudgetMode;
+    /** Base LOD distance in world units for "limit" mode; defaults to 100. Must be finite and positive. */
+    lodBaseDistance?: number;
+    /** Distance multiplier between LOD levels in both modes; defaults to 2. Must be finite and at least 1. */
+    lodMultiplier?: number;
+  };
 export type SogStreamStats = StreamStats & {
   visibleRegions: number;
 };
@@ -15,6 +23,9 @@ export declare class SogStreamScheduler {
   readonly fadeDurationMs: number;
   readonly maxConcurrentLoads: number;
   private _splatBudget;
+  private _splatBudgetMode;
+  private _lodBaseDistance;
+  private _lodMultiplier;
   private readonly options;
   private readonly loader;
   private readonly abort;
@@ -37,9 +48,18 @@ export declare class SogStreamScheduler {
   private resolveFirst;
   private rejectFirst;
   constructor(options: SogStreamSchedulerOptions);
-  /** Visible-point target, including the environment. Reassign to reselect LODs. */
+  /** Visible-point budget, including the environment. Reassign to reselect LODs. */
   get splatBudget(): number;
   set splatBudget(value: number);
+  /** Fill the budget, or limit detail to the configured distance bands. */
+  get splatBudgetMode(): SogBudgetMode;
+  set splatBudgetMode(value: SogBudgetMode);
+  /** Base LOD distance in world units for limit mode. Higher retains more detail. */
+  get lodBaseDistance(): number;
+  set lodBaseDistance(value: number);
+  /** Distance multiplier between LOD levels; affects both budget modes. */
+  get lodMultiplier(): number;
+  set lodMultiplier(value: number);
   get stats(): SogStreamStats;
   /** Group-local bounds from the index; available after initialized resolves. */
   getBoundingBox(): THREE.Box3;

package/dist/types/loaders/stream/sog-stream/sogLod.d.cts

@@ -9,7 +9,7 @@ export type SogLodRange = {
 };
 export type SogLodLeaf = {
   id: number;
-  /** Coarse to fine, with strictly increasing counts and decreasing levels. */
+  /** Coarse to fine, with strictly decreasing levels. */
   lods: SogLodRange[];
 };
 export type SogLodNode = {
@@ -25,8 +25,7 @@ export type SogLodFile = {
 export type SogLodManifest = {
   tree: SogLodNode;
   leaves: SogLodLeaf[];
-  /** Flattened in leaf/LOD order; each leaf's first entry is unused. */
-  upgradeRatios: number[];
+  lodLevels: number;
   files: SogLodFile[];
   environment?: string;
 };
@@ -38,14 +37,13 @@ export type SogLodIndex = {
   leafOffsets: Uint32Array;
   /** Per level: level, file, offset, count. */
   lods: Float64Array;
-  /** Best reachable distance-error reduction per added splat, in LOD order. */
-  upgradeRatios: Float32Array;
+  lodLevels: number;
   urls: string[];
   counts: Float64Array;
   environment?: string;
 };
 /** Scheduler metadata; the complete spatial tree stays in the LOD worker. */
-export type SogLodMetadata = Omit<SogLodIndex, "nodes" | "upgradeRatios"> & {
+export type SogLodMetadata = Omit<SogLodIndex, "nodes" | "lodLevels"> & {
   /** Root min XYZ and max XYZ. */
   bounds: Float64Array;
 };
@@ -63,7 +61,15 @@ export declare function parseSogLodManifest(
 ): SogLodManifest;
 export type SogVisibleLeaf = {
   leaf: SogLodLeaf;
-  weight: number;
+  /** World-space distance to the region, compensated for the camera's field of view. */
+  distance: number;
+};
+export type SogBudgetMode = "target" | "limit";
+export type SogLodOptions = {
+  budget: number;
+  splatBudgetMode: SogBudgetMode;
+  lodBaseDistance: number;
+  lodMultiplier: number;
 };
 /** Reuse cached refinements up to the target, then split gaps of four or more. */
 export declare function resolveSogLod(
@@ -77,9 +83,9 @@ export declare function resolveSogLod(
   /** Wait until range is attached before requesting the next LOD. */
   refinement?: boolean;
 };
-/** Distance bands within a splat budget, using a small heap. */
+/** Select distance bands, fitting their common base distance to the splat budget. */
 export declare function selectSogLods(
   visible: SogVisibleLeaf[],
-  budget: number,
-  manifest: Pick<SogLodIndex, "leafOffsets" | "upgradeRatios">,
+  lodLevels: number,
+  options: SogLodOptions,
 ): Map<number, SogLodRange>;