gaussian-splat-lite 1.2.2 → 1.3.1

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

@@ -1,59 +1,3 @@
-declare const rpcHandlers: {
-    prepareRadSelection(request: Parameters<typeof import('./prepareRadSelection').prepareRadSelection>[0]): {
-        selection: {
-            indices: Uint32Array;
-            wantedChunks: Uint32Array;
-            touchedChunks: Uint32Array;
-            selectionId: number;
-            changedChunks: Uint32Array;
-        };
-        fade: boolean;
-        pools: import('../../../data/RadPagedSplats').RadPreparedSelection[];
-    };
-    initializeRad({ bytes }: {
-        bytes: Uint8Array;
-    }): import('../../rad/radFormat').RadHeader;
-    initializeRadDecoder({ header: value, rootBytes, }: {
-        header: import('../../rad/radFormat').RadHeader;
-        rootBytes?: Uint8Array;
-    }): void;
-    loadRadChunk({ index, generation, request, }: {
-        index: number;
-        generation: number;
-        request: import('../../rad/RadSource').RadReadRequest;
-    }, { sendStatus }: {
-        sendStatus: (data: {
-            loaded: number;
-        }) => void;
-    }): Promise<{
-        data: {
-            numSplats: number;
-            splatArrays: [Uint32Array<ArrayBufferLike>, Uint32Array<ArrayBufferLike>];
-            extra: import('../../../data/defines').SplatExtra;
-            rootRadius: number | undefined;
-        } & import('../../../data/defines').SplatResult & {
-            sourceIds: Uint32Array;
-            centerOnlyBoundingBox: Float32Array;
-            boundingBox: Float32Array;
-            spatialBounds: Float32Array;
-        };
-        tree: import('./radLod').RadLodChunk;
-        state: import('../../rad/RadSource').RadResourceState | undefined;
-        rootBytes: Uint8Array<ArrayBufferLike> | undefined;
-    }>;
-    cancelRadLoad({ generation }: {
-        generation: number;
-    }): void;
-    retainRadChunk({ index, generation, tree, }: {
-        index: number;
-        generation: number;
-        tree: import('./radLod').RadLodChunk;
-    }): void;
-    selectRadLod(request: import('./RadSelectionState').RadSelectionRequest): import('./RadSelectionState').RadSelectionReply;
-    releaseRadChunk({ index, generation, }: {
-        index: number;
-        generation?: number;
-    }): void;
-};
-export type RadStreamRpcHandlers = typeof rpcHandlers;
-export {};
+import type { createRadStreamHandlers } from "./workerHandlers.js";
+
+export type RadStreamRpcHandlers = ReturnType<typeof createRadStreamHandlers>;

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

@@ -1,63 +1,60 @@
-import { RadReadRequest } from '../../rad/RadSource.cjs';
-import { RadHeader } from '../../rad/radFormat.cjs';
-import { RadSelectionReply, RadSelectionRequest } from './RadSelectionState.cjs';
-import { prepareRadSelection } from './prepareRadSelection.cjs';
-import { RadLodChunk } from './radLod.cjs';
-/** Each worker initializes once as either the dataset LOD tree or a page decoder. */
+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 {
+  RadSelectionChunk,
+  RadSelectionPreparation,
+  prepareRadSelection,
+} from "./prepareRadSelection.cjs";
+import type { RadLodChunk } from "./radLod.cjs";
+/** 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, }: {
-        header: RadHeader;
-        rootBytes?: Uint8Array;
-    }): void;
-    loadRadChunk({ index, generation, request, }: {
-        index: number;
-        generation: number;
-        request: 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: 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: RadLodChunk;
-    }): void;
-    selectRadLod(request: RadSelectionRequest): RadSelectionReply;
-    releaseRadChunk({ index, generation, }: {
-        index: number;
-        generation?: number;
-    }): void;
+  prepareRadSelection(
+    request: Parameters<typeof prepareRadSelection>[0],
+  ): RadSelectionPreparation;
+  initializeRad(request: { bytes: Uint8Array }): RadHeader;
+  initializeRadDecoder(request: {
+    header: RadHeader;
+    rootBytes?: Uint8Array;
+  }): void;
+  loadRadChunk(
+    args: {
+      index: number;
+      generation: number;
+      request: RadReadRequest;
+    },
+    options: {
+      sendStatus: (data: {
+        loaded: number;
+      }) => void;
+    },
+  ): Promise<{
+    data: RadStreamChunk;
+    tree: RadLodChunk;
+    state: RadResourceState | undefined;
+    rootBytes: Uint8Array<ArrayBufferLike> | undefined;
+  }>;
+  cancelRadLoad(request: { generation: number }): void;
+  retainRadChunk(request: {
+    index: number;
+    generation: number;
+    tree: Omit<RadLodChunk, keyof RadSelectionChunk>;
+  }): void;
+  retainRadSelectionChunk(request: {
+    index: number;
+    generation: number;
+    chunk: RadSelectionChunk;
+  }): number;
+  selectRadLod(request: RadSelectionRequest): RadSelectionReply;
+  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,63 +1,60 @@
-import { RadReadRequest } from '../../rad/RadSource';
-import { RadHeader } from '../../rad/radFormat';
-import { RadSelectionReply, RadSelectionRequest } from './RadSelectionState';
-import { prepareRadSelection } from './prepareRadSelection';
-import { RadLodChunk } from './radLod';
-/** Each worker initializes once as either the dataset LOD tree or a page decoder. */
+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 {
+  RadSelectionChunk,
+  RadSelectionPreparation,
+  prepareRadSelection,
+} from "./prepareRadSelection.js";
+import type { RadLodChunk } from "./radLod.js";
+/** 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').RadPreparedSelection[];
-    };
-    initializeRad({ bytes }: {
-        bytes: Uint8Array;
-    }): RadHeader;
-    initializeRadDecoder({ header: value, rootBytes, }: {
-        header: RadHeader;
-        rootBytes?: Uint8Array;
-    }): void;
-    loadRadChunk({ index, generation, request, }: {
-        index: number;
-        generation: number;
-        request: RadReadRequest;
-    }, { sendStatus }: {
-        sendStatus: (data: {
-            loaded: number;
-        }) => void;
-    }): Promise<{
-        data: {
-            numSplats: number;
-            splatArrays: [Uint32Array<ArrayBufferLike>, Uint32Array<ArrayBufferLike>];
-            extra: import('../../../data/defines').SplatExtra;
-            rootRadius: number | undefined;
-        } & import('../../../data/defines').SplatResult & {
-            sourceIds: Uint32Array;
-            centerOnlyBoundingBox: Float32Array;
-            boundingBox: Float32Array;
-            spatialBounds: Float32Array;
-        };
-        tree: RadLodChunk;
-        state: import('../../rad/RadSource').RadResourceState | undefined;
-        rootBytes: Uint8Array<ArrayBufferLike> | undefined;
-    }>;
-    cancelRadLoad({ generation }: {
-        generation: number;
-    }): void;
-    retainRadChunk({ index, generation, tree, }: {
-        index: number;
-        generation: number;
-        tree: RadLodChunk;
-    }): void;
-    selectRadLod(request: RadSelectionRequest): RadSelectionReply;
-    releaseRadChunk({ index, generation, }: {
-        index: number;
-        generation?: number;
-    }): void;
+  prepareRadSelection(
+    request: Parameters<typeof prepareRadSelection>[0],
+  ): RadSelectionPreparation;
+  initializeRad(request: { bytes: Uint8Array }): RadHeader;
+  initializeRadDecoder(request: {
+    header: RadHeader;
+    rootBytes?: Uint8Array;
+  }): void;
+  loadRadChunk(
+    args: {
+      index: number;
+      generation: number;
+      request: RadReadRequest;
+    },
+    options: {
+      sendStatus: (data: {
+        loaded: number;
+      }) => void;
+    },
+  ): Promise<{
+    data: RadStreamChunk;
+    tree: RadLodChunk;
+    state: RadResourceState | undefined;
+    rootBytes: Uint8Array<ArrayBufferLike> | undefined;
+  }>;
+  cancelRadLoad(request: { generation: number }): void;
+  retainRadChunk(request: {
+    index: number;
+    generation: number;
+    tree: Omit<RadLodChunk, keyof RadSelectionChunk>;
+  }): void;
+  retainRadSelectionChunk(request: {
+    index: number;
+    generation: number;
+    chunk: RadSelectionChunk;
+  }): number;
+  selectRadLod(request: RadSelectionRequest): RadSelectionReply;
+  releaseRadChunk(request: {
+    index: number;
+    generation?: number;
+  }): void;
+  releaseRadSelectionChunk(request: {
+    index: number;
+    generation?: number;
+  }): number;
 };

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

@@ -1,16 +1,20 @@
-import { ReorderedSplatResult } from '../../../data/defines.cjs';
-import { SplatMesh } from '../../../scene/SplatMesh.cjs';
 import type * as THREE from "three";
+import type { ReorderedSplatResult } from "../../../data/defines.cjs";
+import { SplatMesh } from "../../../scene/SplatMesh.cjs";
 /** Regions share one source, one scene node and one accumulator generation call. */
 export declare class SogStreamBatch extends SplatMesh {
-    readonly numSh: number;
-    private readonly group;
-    private readonly onEmpty;
-    private readonly source;
-    private readonly slots;
-    constructor(capacity: number, numSh: number, group: THREE.Group, onEmpty: () => void);
-    get residentBytes(): number;
-    writeRegion(start: number, data: ReorderedSplatResult): void;
-    setRegionOpacity(start: number, opacity: number): void;
-    releaseRegion(start: number): void;
+  readonly numSh: number;
+  private readonly group;
+  private readonly onEmpty;
+  private readonly source;
+  private readonly slots;
+  constructor(
+    capacity: number,
+    numSh: number,
+    group: THREE.Group,
+    onEmpty: () => void,
+  );
+  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

@@ -1,16 +1,20 @@
-import { ReorderedSplatResult } from '../../../data/defines';
-import { SplatMesh } from '../../../scene/SplatMesh';
 import type * as THREE from "three";
+import type { ReorderedSplatResult } from "../../../data/defines.js";
+import { SplatMesh } from "../../../scene/SplatMesh.js";
 /** Regions share one source, one scene node and one accumulator generation call. */
 export declare class SogStreamBatch extends SplatMesh {
-    readonly numSh: number;
-    private readonly group;
-    private readonly onEmpty;
-    private readonly source;
-    private readonly slots;
-    constructor(capacity: number, numSh: number, group: THREE.Group, onEmpty: () => void);
-    get residentBytes(): number;
-    writeRegion(start: number, data: ReorderedSplatResult): void;
-    setRegionOpacity(start: number, opacity: number): void;
-    releaseRegion(start: number): void;
+  readonly numSh: number;
+  private readonly group;
+  private readonly onEmpty;
+  private readonly source;
+  private readonly slots;
+  constructor(
+    capacity: number,
+    numSh: number,
+    group: THREE.Group,
+    onEmpty: () => void,
+  );
+  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

@@ -1,49 +1,64 @@
-import { Splats } from '../../../data/Splats.cjs';
-import { StreamRequestOptions } from '../streamOptions.cjs';
-import { SogStreamWorker } from './SogStreamWorker.cjs';
-import { SogLodMetadata } from './sogLod.cjs';
-import { SogView } from './sogVisibility.cjs';
-import { SogChunkInfo } from './workerHandlers.cjs';
+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 { SogLodRequest } from "./sogVisibility.cjs";
+import type { SogChunkInfo } from "./workerHandlers.cjs";
 export type SogStreamLoaderOptions = StreamRequestOptions & {
-    url: string;
-    /** Returns owned data in file order, or with a complete source ID map. */
-    loadChunk?: (url: string, signal: AbortSignal) => Promise<Splats>;
+  url: string;
+  /** Returns owned data in file order, or with a complete source ID map. */
+  loadChunk?: (url: string, signal: AbortSignal) => Promise<Splats>;
 };
 /** A retained worker cache; extraction transfers owned packed arrays to the caller. */
 export declare class SogChunkSource {
-    private readonly worker;
-    private readonly id;
-    readonly info: SogChunkInfo;
-    private readonly onRelease;
-    private released;
-    constructor(worker: SogStreamWorker, id: number, info: SogChunkInfo, onRelease: () => void);
-    get alive(): boolean;
-    extract(ranges: {
-        start: number;
-        count: number;
-    }[]): Promise<import('../../../data/defines.cjs').ReorderedSplatResult[]>;
-    dispose(): void;
+  private readonly worker;
+  private readonly id;
+  readonly info: SogChunkInfo;
+  private readonly onRelease;
+  private released;
+  constructor(
+    worker: SogStreamWorker,
+    id: number,
+    info: SogChunkInfo,
+    onRelease: () => void,
+  );
+  get alive(): boolean;
+  extract(
+    ranges: {
+      start: number;
+      count: number;
+    }[],
+  ): Promise<import("../../../data/defines.cjs").ReorderedSplatResult[]>;
+  dispose(): void;
 }
 /** Dedicated LOD worker, bounded decoders and retained chunk cache handles. */
 export declare class SogStreamLoader {
-    private readonly options;
-    private readonly lodWorker;
-    private readonly pool;
-    private readonly controller;
-    private initialization?;
-    private baseUrl;
-    private downloadedBytes;
-    private retainedIndexBytes;
-    constructor(options: SogStreamLoaderOptions, maxConcurrentLoads: number, onChange: () => void);
-    get stats(): {
-        downloadedBytes: number;
-        peakWasmMemoryBytes: number;
-        retainedIndexBytes: number;
-    };
-    private assertActive;
-    initialize(signal?: AbortSignal): Promise<SogLodMetadata>;
-    private readIndex;
-    selectLod(view: SogView, budget: number): Promise<Uint32Array>;
-    load(url: string, count: number, signal: AbortSignal): Promise<SogChunkSource>;
-    dispose(): void;
+  private readonly options;
+  private readonly lodWorker;
+  private readonly pool;
+  private readonly controller;
+  private initialization?;
+  private baseUrl;
+  private downloadedBytes;
+  private retainedIndexBytes;
+  constructor(
+    options: SogStreamLoaderOptions,
+    maxConcurrentLoads: number,
+    onChange: () => void,
+  );
+  get stats(): {
+    downloadedBytes: number;
+    peakWasmMemoryBytes: number;
+    retainedIndexBytes: number;
+  };
+  private assertActive;
+  initialize(signal?: AbortSignal): Promise<SogLodMetadata>;
+  private readIndex;
+  selectLod(request: SogLodRequest): Promise<Uint32Array>;
+  load(
+    url: string,
+    count: number,
+    signal: AbortSignal,
+  ): Promise<SogChunkSource>;
+  dispose(): void;
 }

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

@@ -1,49 +1,64 @@
-import { Splats } from '../../../data/Splats';
-import { StreamRequestOptions } from '../streamOptions';
-import { SogStreamWorker } from './SogStreamWorker';
-import { SogLodMetadata } from './sogLod';
-import { SogView } from './sogVisibility';
-import { SogChunkInfo } from './workerHandlers';
+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 { SogLodRequest } from "./sogVisibility.js";
+import type { SogChunkInfo } from "./workerHandlers.js";
 export type SogStreamLoaderOptions = StreamRequestOptions & {
-    url: string;
-    /** Returns owned data in file order, or with a complete source ID map. */
-    loadChunk?: (url: string, signal: AbortSignal) => Promise<Splats>;
+  url: string;
+  /** Returns owned data in file order, or with a complete source ID map. */
+  loadChunk?: (url: string, signal: AbortSignal) => Promise<Splats>;
 };
 /** A retained worker cache; extraction transfers owned packed arrays to the caller. */
 export declare class SogChunkSource {
-    private readonly worker;
-    private readonly id;
-    readonly info: SogChunkInfo;
-    private readonly onRelease;
-    private released;
-    constructor(worker: SogStreamWorker, id: number, info: SogChunkInfo, onRelease: () => void);
-    get alive(): boolean;
-    extract(ranges: {
-        start: number;
-        count: number;
-    }[]): Promise<import('../../../data/defines').ReorderedSplatResult[]>;
-    dispose(): void;
+  private readonly worker;
+  private readonly id;
+  readonly info: SogChunkInfo;
+  private readonly onRelease;
+  private released;
+  constructor(
+    worker: SogStreamWorker,
+    id: number,
+    info: SogChunkInfo,
+    onRelease: () => void,
+  );
+  get alive(): boolean;
+  extract(
+    ranges: {
+      start: number;
+      count: number;
+    }[],
+  ): Promise<import("../../../data/defines.js").ReorderedSplatResult[]>;
+  dispose(): void;
 }
 /** Dedicated LOD worker, bounded decoders and retained chunk cache handles. */
 export declare class SogStreamLoader {
-    private readonly options;
-    private readonly lodWorker;
-    private readonly pool;
-    private readonly controller;
-    private initialization?;
-    private baseUrl;
-    private downloadedBytes;
-    private retainedIndexBytes;
-    constructor(options: SogStreamLoaderOptions, maxConcurrentLoads: number, onChange: () => void);
-    get stats(): {
-        downloadedBytes: number;
-        peakWasmMemoryBytes: number;
-        retainedIndexBytes: number;
-    };
-    private assertActive;
-    initialize(signal?: AbortSignal): Promise<SogLodMetadata>;
-    private readIndex;
-    selectLod(view: SogView, budget: number): Promise<Uint32Array>;
-    load(url: string, count: number, signal: AbortSignal): Promise<SogChunkSource>;
-    dispose(): void;
+  private readonly options;
+  private readonly lodWorker;
+  private readonly pool;
+  private readonly controller;
+  private initialization?;
+  private baseUrl;
+  private downloadedBytes;
+  private retainedIndexBytes;
+  constructor(
+    options: SogStreamLoaderOptions,
+    maxConcurrentLoads: number,
+    onChange: () => void,
+  );
+  get stats(): {
+    downloadedBytes: number;
+    peakWasmMemoryBytes: number;
+    retainedIndexBytes: number;
+  };
+  private assertActive;
+  initialize(signal?: AbortSignal): Promise<SogLodMetadata>;
+  private readIndex;
+  selectLod(request: SogLodRequest): Promise<Uint32Array>;
+  load(
+    url: string,
+    count: number,
+    signal: AbortSignal,
+  ): Promise<SogChunkSource>;
+  dispose(): void;
 }