gaussian-splat-lite 1.2.2 → 1.3.0

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

@@ -1,107 +1,115 @@
-import { StreamResolutionSource } from '../StreamCameras';
-import { StreamSchedulerOptions, StreamStats } from '../streamOptions';
-import { RadStreamLoaderOptions } from './RadStreamLoader';
-import * as THREE from "three";
-export type RadStreamSchedulerOptions = RadStreamLoaderOptions & StreamSchedulerOptions;
+import type * as THREE from "three";
+import type { StreamResolutionSource } from "../StreamCameras.js";
+import type { StreamSchedulerOptions, StreamStats } from "../streamOptions.js";
+import type { RadStreamLoaderOptions } from "./RadStreamLoader.js";
+export type RadStreamSchedulerOptions = RadStreamLoaderOptions &
+  StreamSchedulerOptions;
 export type RadStreamStats = StreamStats & {
-    pageBudget: number;
-    lodTimeMs: number;
+  pageBudget: number;
+  lodTimeMs: number;
 };
 /** Camera-driven RAD tree cuts with crossfades, on-demand pages and cooldown. */
 export declare class RadStreamScheduler {
-    private readonly options;
-    readonly group: THREE.Group;
-    readonly initialized: Promise<this>;
-    readonly firstRenderable: Promise<this>;
-    readonly cooldownMs: number;
-    readonly fadeDurationMs: number;
-    readonly maxConcurrentLoads: number;
-    private _splatBudget;
-    private readonly loader;
-    private readonly abort;
-    private readonly streamCameras;
-    private readonly pages;
-    private readonly pools;
-    private readonly bounds;
-    private readonly matrix;
-    private meta?;
-    private pageSize;
-    private pageBudget;
-    private numSh;
-    private maxPagePendingBytes;
-    private disposed;
-    private shown;
-    private displayed?;
-    private ready?;
-    private traversal?;
-    private preparation?;
-    private wanted;
-    private revision;
-    private lastRequestedRevision;
-    private refinementStopped;
-    private lastViewKey;
-    private views;
-    private lodTimeMs;
-    private resolveFirst;
-    private rejectFirst;
-    constructor(options: RadStreamSchedulerOptions);
-    /** Selected-node budget. Assigning a new value requests LOD selection. */
-    get splatBudget(): number;
-    set splatBudget(value: number);
-    /** Cameras that select detail, in registration order. */
-    get cameras(): readonly THREE.Camera[];
-    hasCamera(camera: THREE.Camera): boolean;
-    /**
-     * Select detail for this camera on each update; set its resolution too. For
-     * WebXR register renderer.xr.getCamera(): it selects with its eyes' combined
-     * frustum, sized by an eye's viewport. Returns whether the camera was newly
-     * added.
-     */
-    setCamera(camera: THREE.Camera): boolean;
-    /** Stop selecting detail for this camera. Returns whether it was registered. */
-    deleteCamera(camera: THREE.Camera): boolean;
-    /**
-     * Set a registered camera's render size in CSS pixels, without the device
-     * pixel ratio. Returns whether the camera is registered.
-     */
-    setResolution(camera: THREE.Camera, xOrVec: number | THREE.Vector2, y?: number): boolean;
-    /** Set a registered camera's resolution from renderer.getSize(). */
-    setResolutionFromRenderer(camera: THREE.Camera, renderer: StreamResolutionSource): boolean;
-    get stats(): RadStreamStats;
-    /** Group-local root bounds plus selected Gaussian extents; approximate while streaming. */
-    getBoundingBox(): THREE.Box3;
-    private initialize;
-    /**
-     * Call before rendering. Registered cameras share one cut at the greatest
-     * detail any of them needs.
-     */
-    update(): boolean;
-    private requestSelection;
-    private selectionPagesReady;
-    private prepareSelection;
-    private applySelection;
-    private invalidatePendingSelection;
-    private clearSelectionState;
-    /** Worker snapshots and waiting cuts pin pages without renewing cooldown. */
-    private isPagePinned;
-    private cancelUnusedLoads;
-    private updateFade;
-    private page;
-    private pump;
-    private loadPage;
-    private setInitialBounds;
-    private findSlot;
-    private reservePages;
-    private uploadPages;
-    private releasePage;
-    private releaseUnused;
-    /** Map a raycast hit's rendered index back to its stable file index. */
-    getGlobalIndex(mesh: THREE.Object3D, renderedIndex: number): number;
-    private changed;
-    private failed;
-    private stopRefinement;
-    private scheduleRetry;
-    private retryDeadlines;
-    private readonly retryTimer;
-    dispose(): void;
+  private readonly options;
+  readonly group: THREE.Group;
+  readonly initialized: Promise<this>;
+  readonly firstRenderable: Promise<this>;
+  readonly cooldownMs: number;
+  readonly fadeDurationMs: number;
+  readonly maxConcurrentLoads: number;
+  private _splatBudget;
+  private readonly loader;
+  private readonly abort;
+  private readonly streamCameras;
+  private readonly pages;
+  private readonly pools;
+  private readonly bounds;
+  private readonly matrix;
+  private meta?;
+  private pageSize;
+  private pageBudget;
+  private numSh;
+  private maxPagePendingBytes;
+  private disposed;
+  private shown;
+  private displayed?;
+  private ready?;
+  private traversal?;
+  private preparation?;
+  private wanted;
+  private revision;
+  private lastRequestedRevision;
+  private refinementStopped;
+  private lastViewKey;
+  private views;
+  private lodTimeMs;
+  private resolveFirst;
+  private rejectFirst;
+  constructor(options: RadStreamSchedulerOptions);
+  /** Selected-node budget. Assigning a new value requests LOD selection. */
+  get splatBudget(): number;
+  set splatBudget(value: number);
+  /** Cameras that select detail, in registration order. */
+  get cameras(): readonly THREE.Camera[];
+  hasCamera(camera: THREE.Camera): boolean;
+  /**
+   * Select detail for this camera on each update; set its resolution too. For
+   * WebXR register renderer.xr.getCamera(): it selects with its eyes' combined
+   * frustum, sized by an eye's viewport. Returns whether the camera was newly
+   * added.
+   */
+  setCamera(camera: THREE.Camera): boolean;
+  /** Stop selecting detail for this camera. Returns whether it was registered. */
+  deleteCamera(camera: THREE.Camera): boolean;
+  /**
+   * Set a registered camera's render size in CSS pixels, without the device
+   * pixel ratio. Returns whether the camera is registered.
+   */
+  setResolution(
+    camera: THREE.Camera,
+    xOrVec: number | THREE.Vector2,
+    y?: number,
+  ): boolean;
+  /** Set a registered camera's resolution from renderer.getSize(). */
+  setResolutionFromRenderer(
+    camera: THREE.Camera,
+    renderer: StreamResolutionSource,
+  ): boolean;
+  get stats(): RadStreamStats;
+  /** Group-local root bounds plus selected Gaussian extents; approximate while streaming. */
+  getBoundingBox(): THREE.Box3;
+  private initialize;
+  /**
+   * Call before rendering. Registered cameras share one cut at the greatest
+   * detail any of them needs.
+   */
+  update(): boolean;
+  private requestSelection;
+  private selectionPagesReady;
+  private prepareSelection;
+  private applySelection;
+  private invalidatePendingSelection;
+  private clearSelectionState;
+  /** Worker snapshots and waiting cuts pin pages without renewing cooldown. */
+  private isPagePinned;
+  private cancelUnusedLoads;
+  private updateFade;
+  private page;
+  private pump;
+  private loadPage;
+  private setInitialBounds;
+  private findSlot;
+  private reservePages;
+  private uploadPages;
+  private releasePage;
+  private releaseUnused;
+  /** Map a raycast hit's rendered index back to its stable file index. */
+  getGlobalIndex(mesh: THREE.Object3D, renderedIndex: number): number;
+  private changed;
+  private failed;
+  private stopRefinement;
+  private scheduleRetry;
+  private retryDeadlines;
+  private readonly retryTimer;
+  dispose(): void;
 }

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

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

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

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

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

@@ -1,20 +1,32 @@
-import { RadPreparedSelection, RadSelectionSnapshot } from '../../../data/RadPagedSplats.cjs';
-import { RadStreamSelection } from './radFade.cjs';
-import { RadLodChunk } from './radLod.cjs';
-export type RadSelectionChunk = Pick<RadLodChunk, "sourceToStorage" | "boundsBlocks">;
+import type {
+  RadPreparedSelection,
+  RadSelectionSnapshot,
+} from "../../../data/RadPagedSplats.cjs";
+import type { RadStreamSelection } from "./radFade.cjs";
+import type { RadLodChunk } from "./radLod.cjs";
+export type RadSelectionChunk = Pick<
+  RadLodChunk,
+  "sourceToStorage" | "boundsBlocks"
+>;
 /** The scheduler snapshots and pins resident pages before dispatching this work. */
-export declare function prepareRadSelection({ selection, pools, }: {
+export declare function prepareRadSelection(
+  {
+    selection,
+    pools,
+  }: {
     selection: RadStreamSelection;
     pools: RadSelectionSnapshot[];
-}, chunks: ReadonlyMap<number, RadSelectionChunk>): {
-    selection: {
-        indices: Uint32Array;
-        wantedChunks: Uint32Array;
-        touchedChunks: Uint32Array;
-        selectionId: number;
-        changedChunks: Uint32Array;
-    };
-    fade: boolean;
-    pools: RadPreparedSelection[];
+  },
+  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>;

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

@@ -1,20 +1,32 @@
-import { RadPreparedSelection, RadSelectionSnapshot } from '../../../data/RadPagedSplats';
-import { RadStreamSelection } from './radFade';
-import { RadLodChunk } from './radLod';
-export type RadSelectionChunk = Pick<RadLodChunk, "sourceToStorage" | "boundsBlocks">;
+import type {
+  RadPreparedSelection,
+  RadSelectionSnapshot,
+} from "../../../data/RadPagedSplats.js";
+import type { RadStreamSelection } from "./radFade.js";
+import type { RadLodChunk } from "./radLod.js";
+export type RadSelectionChunk = Pick<
+  RadLodChunk,
+  "sourceToStorage" | "boundsBlocks"
+>;
 /** The scheduler snapshots and pins resident pages before dispatching this work. */
-export declare function prepareRadSelection({ selection, pools, }: {
+export declare function prepareRadSelection(
+  {
+    selection,
+    pools,
+  }: {
     selection: RadStreamSelection;
     pools: RadSelectionSnapshot[];
-}, chunks: ReadonlyMap<number, RadSelectionChunk>): {
-    selection: {
-        indices: Uint32Array;
-        wantedChunks: Uint32Array;
-        touchedChunks: Uint32Array;
-        selectionId: number;
-        changedChunks: Uint32Array;
-    };
-    fade: boolean;
-    pools: RadPreparedSelection[];
+  },
+  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>;

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

@@ -1,16 +1,21 @@
-import { RadMeta } from '../../rad/radFormat.cjs';
-import { RadLodSelection } from './radLod.cjs';
+import type { RadMeta } from "../../rad/radFormat.cjs";
+import type { RadLodSelection } from "./radLod.cjs";
 export type RadFade = {
-    indices: Uint32Array;
-    fades: Uint8Array;
+  indices: Uint32Array;
+  fades: Uint8Array;
 };
 export type RadVersionedSelection = RadLodSelection & {
-    selectionId: number;
+  selectionId: number;
 };
 export type RadStreamSelection = RadVersionedSelection & {
-    changedChunks: Uint32Array;
-    fade?: RadFade;
+  changedChunks: Uint32Array;
+  fade?: RadFade;
 };
 /** Compare sorted cuts and build their optional fade union in one pass. Allocate
  * the union only after a difference, so unchanged decisions allocate no fade. */
-export declare function prepareRadFade(meta: RadMeta, previous: Uint32Array, next: Uint32Array, enableFade: boolean): Pick<RadStreamSelection, "changedChunks" | "fade">;
+export declare function prepareRadFade(
+  meta: RadMeta,
+  previous: Uint32Array,
+  next: Uint32Array,
+  enableFade: boolean,
+): Pick<RadStreamSelection, "changedChunks" | "fade">;

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

@@ -1,16 +1,21 @@
-import { RadMeta } from '../../rad/radFormat';
-import { RadLodSelection } from './radLod';
+import type { RadMeta } from "../../rad/radFormat.js";
+import type { RadLodSelection } from "./radLod.js";
 export type RadFade = {
-    indices: Uint32Array;
-    fades: Uint8Array;
+  indices: Uint32Array;
+  fades: Uint8Array;
 };
 export type RadVersionedSelection = RadLodSelection & {
-    selectionId: number;
+  selectionId: number;
 };
 export type RadStreamSelection = RadVersionedSelection & {
-    changedChunks: Uint32Array;
-    fade?: RadFade;
+  changedChunks: Uint32Array;
+  fade?: RadFade;
 };
 /** Compare sorted cuts and build their optional fade union in one pass. Allocate
  * the union only after a difference, so unchanged decisions allocate no fade. */
-export declare function prepareRadFade(meta: RadMeta, previous: Uint32Array, next: Uint32Array, enableFade: boolean): Pick<RadStreamSelection, "changedChunks" | "fade">;
+export declare function prepareRadFade(
+  meta: RadMeta,
+  previous: Uint32Array,
+  next: Uint32Array,
+  enableFade: boolean,
+): Pick<RadStreamSelection, "changedChunks" | "fade">;

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

@@ -1,37 +1,37 @@
-import { RadMeta } from '../../rad/radFormat.cjs';
+import type { RadMeta } from "../../rad/radFormat.cjs";
 /** CPU-only data retained in the dataset worker, never GPU source storage. */
 export type RadLodChunk = {
-    centers: Float32Array;
-    radii: Float32Array;
-    childStart: Uint32Array;
-    childCount: Uint16Array;
-    /** Original page index to Morton storage; tree arrays keep file order. */
-    sourceToStorage: Uint32Array;
-    /** Center and scale/rotation bounds per Morton storage block. */
-    boundsBlocks: Float32Array;
+  centers: Float32Array;
+  radii: Float32Array;
+  childStart: Uint32Array;
+  childCount: Uint16Array;
+  /** Original page index to Morton storage; tree arrays keep file order. */
+  sourceToStorage: Uint32Array;
+  /** Center and scale/rotation bounds per Morton storage block. */
+  boundsBlocks: Float32Array;
 };
 export type RadLodView = {
-    /** Object-to-camera transform; doubles preserve large scene translations. */
-    viewFromObject: number[];
-    /** Camera projection's X/Y rows (8 values), including zoom and view offsets. */
-    projectionRows: number[];
-    /** Pixels per camera-space unit at depth 1, including projection zoom. */
-    pixelScale: number;
-    orthographic: boolean;
+  /** Object-to-camera transform; doubles preserve large scene translations. */
+  viewFromObject: number[];
+  /** Camera projection's X/Y rows (8 values), including zoom and view offsets. */
+  projectionRows: number[];
+  /** Pixels per camera-space unit at depth 1, including projection zoom. */
+  pixelScale: number;
+  orthographic: boolean;
 };
 export type RadLodRequest = {
-    views: RadLodView[];
-    splatBudget: number;
-    pixelThreshold: number;
-    residentChunks: number[];
-    hysteresis?: number;
+  views: RadLodView[];
+  splatBudget: number;
+  pixelThreshold: number;
+  residentChunks: number[];
+  hysteresis?: number;
 };
 export type RadLodSelection = {
-    /** Stable file indices. The scheduler maps these to occupied GPU slots. */
-    indices: Uint32Array;
-    wantedChunks: Uint32Array;
-    /** Ancestor and selected pages required by this cut. */
-    touchedChunks: Uint32Array;
+  /** Stable file indices. The scheduler maps these to occupied GPU slots. */
+  indices: Uint32Array;
+  wantedChunks: Uint32Array;
+  /** Ancestor and selected pages required by this cut. */
+  touchedChunks: Uint32Array;
 };
 /** Resolve validated LOD indices without assuming that chunks are 64K records. */
 export declare function radChunkIndex(meta: RadMeta, index: number): number;

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

@@ -1,37 +1,37 @@
-import { RadMeta } from '../../rad/radFormat';
+import type { RadMeta } from "../../rad/radFormat.js";
 /** CPU-only data retained in the dataset worker, never GPU source storage. */
 export type RadLodChunk = {
-    centers: Float32Array;
-    radii: Float32Array;
-    childStart: Uint32Array;
-    childCount: Uint16Array;
-    /** Original page index to Morton storage; tree arrays keep file order. */
-    sourceToStorage: Uint32Array;
-    /** Center and scale/rotation bounds per Morton storage block. */
-    boundsBlocks: Float32Array;
+  centers: Float32Array;
+  radii: Float32Array;
+  childStart: Uint32Array;
+  childCount: Uint16Array;
+  /** Original page index to Morton storage; tree arrays keep file order. */
+  sourceToStorage: Uint32Array;
+  /** Center and scale/rotation bounds per Morton storage block. */
+  boundsBlocks: Float32Array;
 };
 export type RadLodView = {
-    /** Object-to-camera transform; doubles preserve large scene translations. */
-    viewFromObject: number[];
-    /** Camera projection's X/Y rows (8 values), including zoom and view offsets. */
-    projectionRows: number[];
-    /** Pixels per camera-space unit at depth 1, including projection zoom. */
-    pixelScale: number;
-    orthographic: boolean;
+  /** Object-to-camera transform; doubles preserve large scene translations. */
+  viewFromObject: number[];
+  /** Camera projection's X/Y rows (8 values), including zoom and view offsets. */
+  projectionRows: number[];
+  /** Pixels per camera-space unit at depth 1, including projection zoom. */
+  pixelScale: number;
+  orthographic: boolean;
 };
 export type RadLodRequest = {
-    views: RadLodView[];
-    splatBudget: number;
-    pixelThreshold: number;
-    residentChunks: number[];
-    hysteresis?: number;
+  views: RadLodView[];
+  splatBudget: number;
+  pixelThreshold: number;
+  residentChunks: number[];
+  hysteresis?: number;
 };
 export type RadLodSelection = {
-    /** Stable file indices. The scheduler maps these to occupied GPU slots. */
-    indices: Uint32Array;
-    wantedChunks: Uint32Array;
-    /** Ancestor and selected pages required by this cut. */
-    touchedChunks: Uint32Array;
+  /** Stable file indices. The scheduler maps these to occupied GPU slots. */
+  indices: Uint32Array;
+  wantedChunks: Uint32Array;
+  /** Ancestor and selected pages required by this cut. */
+  touchedChunks: Uint32Array;
 };
 /** Resolve validated LOD indices without assuming that chunks are 64K records. */
 export declare function radChunkIndex(meta: RadMeta, index: number): number;

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

@@ -1,59 +1,3 @@
-declare const rpcHandlers: {
-    prepareRadSelection(request: Parameters<typeof import('./prepareRadSelection.cjs').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;
-    }): import('../../rad/radFormat.cjs').RadHeader;
-    initializeRadDecoder({ header: value, rootBytes, }: {
-        header: import('../../rad/radFormat.cjs').RadHeader;
-        rootBytes?: Uint8Array;
-    }): void;
-    loadRadChunk({ index, generation, request, }: {
-        index: number;
-        generation: number;
-        request: import('../../rad/RadSource.cjs').RadReadRequest;
-    }, { sendStatus }: {
-        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;
-        };
-        tree: import('./radLod.cjs').RadLodChunk;
-        state: import('../../rad/RadSource.cjs').RadResourceState | undefined;
-        rootBytes: Uint8Array<ArrayBufferLike> | undefined;
-    }>;
-    cancelRadLoad({ generation }: {
-        generation: number;
-    }): void;
-    retainRadChunk({ index, generation, tree, }: {
-        index: number;
-        generation: number;
-        tree: import('./radLod.cjs').RadLodChunk;
-    }): void;
-    selectRadLod(request: import('./RadSelectionState.cjs').RadSelectionRequest): import('./RadSelectionState.cjs').RadSelectionReply;
-    releaseRadChunk({ index, generation, }: {
-        index: number;
-        generation?: number;
-    }): void;
-};
-export type RadStreamRpcHandlers = typeof rpcHandlers;
-export {};
+import type { createRadStreamHandlers } from "./workerHandlers.cjs";
+
+export type RadStreamRpcHandlers = ReturnType<typeof createRadStreamHandlers>;