gaussian-splat-lite 1.2.2 → 1.3.0

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

@@ -1,35 +1,43 @@
-import { SogLodIndex } from './sogLod.cjs';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { SogLodIndex } from "./sogLod.cjs";
 export type SogCamera = {
-    modelView: number[];
-    projection: number[];
-    coordinateSystem: THREE.CoordinateSystem;
-    reversedDepth: boolean;
+  modelView: number[];
+  projection: number[];
+  coordinateSystem: THREE.CoordinateSystem;
+  reversedDepth: boolean;
 };
 export type SogView = {
-    /** The registered cameras that see the group; selection serves all of them. */
-    cameras: SogCamera[];
-    shown: boolean;
+  /** The registered cameras that see the group; selection serves all of them. */
+  cameras: SogCamera[];
+  shown: boolean;
 };
 /**
  * Capture the cameras that see the group without traversing the manifest or
  * reducing matrix precision. WebXR selects detail from each eye's current pose and frustum.
  */
-export declare function captureSogView(cameras: readonly THREE.Camera[], group: THREE.Object3D): SogView;
+export declare function captureSogView(
+  cameras: readonly THREE.Camera[],
+  group: THREE.Object3D,
+): SogView;
 /** Stable key of a view, for skipping unchanged selection requests. */
 export declare function getSogViewKey(view: SogView): string;
 /** Worker traversal state keeps leaf identities stable between selections. */
 export declare class SogVisibility {
-    private readonly manifest;
-    private readonly leaves;
-    private readonly cameras;
-    private readonly clip;
-    private readonly bound;
-    private readonly closest;
-    private readonly inverseModelView;
-    constructor(manifest: Pick<SogLodIndex, "nodes" | "leafOffsets" | "lods" | "upgradeRatios">);
-    private prepareCameras;
-    private collect;
-    /** Transfer only [leaf ID, LOD ordinal] pairs in loading priority order. */
-    select(view: SogView, budget: number): Uint32Array;
+  private readonly manifest;
+  private readonly leaves;
+  private readonly cameras;
+  private readonly clip;
+  private readonly bound;
+  private readonly closest;
+  private readonly inverseModelView;
+  constructor(
+    manifest: Pick<
+      SogLodIndex,
+      "nodes" | "leafOffsets" | "lods" | "upgradeRatios"
+    >,
+  );
+  private prepareCameras;
+  private collect;
+  /** Transfer only [leaf ID, LOD ordinal] pairs in loading priority order. */
+  select(view: SogView, budget: number): Uint32Array;
 }

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

@@ -1,35 +1,43 @@
-import { SogLodIndex } from './sogLod';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { SogLodIndex } from "./sogLod.js";
 export type SogCamera = {
-    modelView: number[];
-    projection: number[];
-    coordinateSystem: THREE.CoordinateSystem;
-    reversedDepth: boolean;
+  modelView: number[];
+  projection: number[];
+  coordinateSystem: THREE.CoordinateSystem;
+  reversedDepth: boolean;
 };
 export type SogView = {
-    /** The registered cameras that see the group; selection serves all of them. */
-    cameras: SogCamera[];
-    shown: boolean;
+  /** The registered cameras that see the group; selection serves all of them. */
+  cameras: SogCamera[];
+  shown: boolean;
 };
 /**
  * Capture the cameras that see the group without traversing the manifest or
  * reducing matrix precision. WebXR selects detail from each eye's current pose and frustum.
  */
-export declare function captureSogView(cameras: readonly THREE.Camera[], group: THREE.Object3D): SogView;
+export declare function captureSogView(
+  cameras: readonly THREE.Camera[],
+  group: THREE.Object3D,
+): SogView;
 /** Stable key of a view, for skipping unchanged selection requests. */
 export declare function getSogViewKey(view: SogView): string;
 /** Worker traversal state keeps leaf identities stable between selections. */
 export declare class SogVisibility {
-    private readonly manifest;
-    private readonly leaves;
-    private readonly cameras;
-    private readonly clip;
-    private readonly bound;
-    private readonly closest;
-    private readonly inverseModelView;
-    constructor(manifest: Pick<SogLodIndex, "nodes" | "leafOffsets" | "lods" | "upgradeRatios">);
-    private prepareCameras;
-    private collect;
-    /** Transfer only [leaf ID, LOD ordinal] pairs in loading priority order. */
-    select(view: SogView, budget: number): Uint32Array;
+  private readonly manifest;
+  private readonly leaves;
+  private readonly cameras;
+  private readonly clip;
+  private readonly bound;
+  private readonly closest;
+  private readonly inverseModelView;
+  constructor(
+    manifest: Pick<
+      SogLodIndex,
+      "nodes" | "leafOffsets" | "lods" | "upgradeRatios"
+    >,
+  );
+  private prepareCameras;
+  private collect;
+  /** Transfer only [leaf ID, LOD ordinal] pairs in loading priority order. */
+  select(view: SogView, budget: number): Uint32Array;
 }

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

@@ -1,41 +1,8 @@
-import { resolveAsset } from '../../workerDecode.cjs';
-declare const rpcHandlers: {
-    resolveAsset: typeof resolveAsset;
-    loadSogChunk: ({ id, ...args }: import('../../loadTypes.cjs').SplatLoadArgs & {
-        id: number;
-    }, options: {
-        sendStatus: (data: import('../../loadTypes.cjs').SplatLoadStatus) => void;
-    }) => Promise<import('./workerHandlers.cjs').SogChunkInfo>;
-    cacheSogChunk: ({ id, data, }: {
-        id: number;
-        data: import('../../../data/defines.cjs').SplatResult;
-    }) => import('./workerHandlers.cjs').SogChunkInfo;
-    extractSogRegions: ({ id, ranges, }: {
-        id: number;
-        ranges: {
-            start: number;
-            count: number;
-        }[];
-    }) => import('../../../data/defines.cjs').ReorderedSplatResult[];
-    releaseSogChunk: ({ id }: {
-        id: number;
-    }) => void;
-    parseSogIndex: ({ bytes, baseUrl, }: {
-        bytes: ArrayBuffer;
-        baseUrl: string;
-    }) => {
-        bounds: Float64Array<ArrayBuffer>;
-        leafOffsets: Uint32Array<ArrayBuffer>;
-        lods: Float64Array<ArrayBuffer>;
-        retainedIndexBytes: number;
-        urls: string[];
-        counts: Float64Array;
-        environment?: string;
-    };
-    selectSogLod: ({ view, budget }: {
-        view: import('./sogVisibility.cjs').SogView;
-        budget: number;
-    }) => Uint32Array<ArrayBufferLike>;
+import type { resolveAsset } from "../../workerDecode.cjs";
+import type { createSogStreamHandlers } from "./workerHandlers.cjs";
+
+export type SogStreamRpcHandlers = ReturnType<
+  typeof createSogStreamHandlers
+> & {
+  resolveAsset: typeof resolveAsset;
 };
-export type SogStreamRpcHandlers = typeof rpcHandlers;
-export {};

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

@@ -1,41 +1,8 @@
-import { resolveAsset } from '../../workerDecode';
-declare const rpcHandlers: {
-    resolveAsset: typeof resolveAsset;
-    loadSogChunk: ({ id, ...args }: import('../../loadTypes').SplatLoadArgs & {
-        id: number;
-    }, options: {
-        sendStatus: (data: import('../../loadTypes').SplatLoadStatus) => void;
-    }) => Promise<import('./workerHandlers').SogChunkInfo>;
-    cacheSogChunk: ({ id, data, }: {
-        id: number;
-        data: import('../../../data/defines').SplatResult;
-    }) => import('./workerHandlers').SogChunkInfo;
-    extractSogRegions: ({ id, ranges, }: {
-        id: number;
-        ranges: {
-            start: number;
-            count: number;
-        }[];
-    }) => import('../../../data/defines').ReorderedSplatResult[];
-    releaseSogChunk: ({ id }: {
-        id: number;
-    }) => void;
-    parseSogIndex: ({ bytes, baseUrl, }: {
-        bytes: ArrayBuffer;
-        baseUrl: string;
-    }) => {
-        bounds: Float64Array<ArrayBuffer>;
-        leafOffsets: Uint32Array<ArrayBuffer>;
-        lods: Float64Array<ArrayBuffer>;
-        retainedIndexBytes: number;
-        urls: string[];
-        counts: Float64Array;
-        environment?: string;
-    };
-    selectSogLod: ({ view, budget }: {
-        view: import('./sogVisibility').SogView;
-        budget: number;
-    }) => Uint32Array<ArrayBufferLike>;
+import type { resolveAsset } from "../../workerDecode.js";
+import type { createSogStreamHandlers } from "./workerHandlers.js";
+
+export type SogStreamRpcHandlers = ReturnType<
+  typeof createSogStreamHandlers
+> & {
+  resolveAsset: typeof resolveAsset;
 };
-export type SogStreamRpcHandlers = typeof rpcHandlers;
-export {};

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

@@ -1,48 +1,73 @@
-import { SplatResult } from '../../../data/defines.cjs';
-import { SplatLoadArgs, SplatLoadStatus } from '../../loadTypes.cjs';
-import { SogView } from './sogVisibility.cjs';
+import type { SplatResult } from "../../../data/defines.cjs";
+import type { SplatLoadArgs, SplatLoadStatus } from "../../loadTypes.cjs";
+import type { SogView } from "./sogVisibility.cjs";
 export type SogChunkInfo = {
-    numSplats: number;
-    numSh: number;
-    byteLength: number;
+  numSplats: number;
+  numSh: number;
+  byteLength: number;
 };
 /** LOD workers parse the index once before selection; other workers own chunk caches. */
-export declare function createSogStreamHandlers(decodeSplats: (args: SplatLoadArgs, options: {
-    sendStatus: (data: SplatLoadStatus) => void;
-}) => Promise<SplatResult>): {
-    loadSogChunk: ({ id, ...args }: SplatLoadArgs & {
-        id: number;
-    }, options: {
-        sendStatus: (data: SplatLoadStatus) => void;
-    }) => Promise<SogChunkInfo>;
-    cacheSogChunk: ({ id, data, }: {
-        id: number;
-        data: SplatResult;
-    }) => SogChunkInfo;
-    extractSogRegions: ({ id, ranges, }: {
-        id: number;
-        ranges: {
-            start: number;
-            count: number;
-        }[];
-    }) => import('../../../data/defines.cjs').ReorderedSplatResult[];
-    releaseSogChunk: ({ id }: {
-        id: number;
-    }) => void;
-    parseSogIndex: ({ bytes, baseUrl, }: {
-        bytes: ArrayBuffer;
-        baseUrl: string;
-    }) => {
-        bounds: Float64Array<ArrayBuffer>;
-        leafOffsets: Uint32Array<ArrayBuffer>;
-        lods: Float64Array<ArrayBuffer>;
-        retainedIndexBytes: number;
-        urls: string[];
-        counts: Float64Array;
-        environment?: string;
-    };
-    selectSogLod: ({ view, budget }: {
-        view: SogView;
-        budget: number;
-    }) => Uint32Array<ArrayBufferLike>;
+export declare function createSogStreamHandlers(
+  decodeSplats: (
+    args: SplatLoadArgs,
+    options: {
+      sendStatus: (data: SplatLoadStatus) => void;
+    },
+  ) => Promise<SplatResult>,
+): {
+  loadSogChunk: (
+    {
+      id,
+      ...args
+    }: SplatLoadArgs & {
+      id: number;
+    },
+    options: {
+      sendStatus: (data: SplatLoadStatus) => void;
+    },
+  ) => Promise<SogChunkInfo>;
+  cacheSogChunk: ({
+    id,
+    data,
+  }: {
+    id: number;
+    data: SplatResult;
+  }) => SogChunkInfo;
+  extractSogRegions: ({
+    id,
+    ranges,
+  }: {
+    id: number;
+    ranges: {
+      start: number;
+      count: number;
+    }[];
+  }) => import("../../../data/defines.cjs").ReorderedSplatResult[];
+  releaseSogChunk: ({
+    id,
+  }: {
+    id: number;
+  }) => void;
+  parseSogIndex: ({
+    bytes,
+    baseUrl,
+  }: {
+    bytes: ArrayBuffer;
+    baseUrl: string;
+  }) => {
+    bounds: Float64Array<ArrayBuffer>;
+    leafOffsets: Uint32Array<ArrayBuffer>;
+    lods: Float64Array<ArrayBuffer>;
+    retainedIndexBytes: number;
+    urls: string[];
+    counts: Float64Array;
+    environment?: string;
+  };
+  selectSogLod: ({
+    view,
+    budget,
+  }: {
+    view: SogView;
+    budget: number;
+  }) => Uint32Array<ArrayBufferLike>;
 };

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

@@ -1,48 +1,73 @@
-import { SplatResult } from '../../../data/defines';
-import { SplatLoadArgs, SplatLoadStatus } from '../../loadTypes';
-import { SogView } from './sogVisibility';
+import type { SplatResult } from "../../../data/defines.js";
+import type { SplatLoadArgs, SplatLoadStatus } from "../../loadTypes.js";
+import type { SogView } from "./sogVisibility.js";
 export type SogChunkInfo = {
-    numSplats: number;
-    numSh: number;
-    byteLength: number;
+  numSplats: number;
+  numSh: number;
+  byteLength: number;
 };
 /** LOD workers parse the index once before selection; other workers own chunk caches. */
-export declare function createSogStreamHandlers(decodeSplats: (args: SplatLoadArgs, options: {
-    sendStatus: (data: SplatLoadStatus) => void;
-}) => Promise<SplatResult>): {
-    loadSogChunk: ({ id, ...args }: SplatLoadArgs & {
-        id: number;
-    }, options: {
-        sendStatus: (data: SplatLoadStatus) => void;
-    }) => Promise<SogChunkInfo>;
-    cacheSogChunk: ({ id, data, }: {
-        id: number;
-        data: SplatResult;
-    }) => SogChunkInfo;
-    extractSogRegions: ({ id, ranges, }: {
-        id: number;
-        ranges: {
-            start: number;
-            count: number;
-        }[];
-    }) => import('../../../data/defines').ReorderedSplatResult[];
-    releaseSogChunk: ({ id }: {
-        id: number;
-    }) => void;
-    parseSogIndex: ({ bytes, baseUrl, }: {
-        bytes: ArrayBuffer;
-        baseUrl: string;
-    }) => {
-        bounds: Float64Array<ArrayBuffer>;
-        leafOffsets: Uint32Array<ArrayBuffer>;
-        lods: Float64Array<ArrayBuffer>;
-        retainedIndexBytes: number;
-        urls: string[];
-        counts: Float64Array;
-        environment?: string;
-    };
-    selectSogLod: ({ view, budget }: {
-        view: SogView;
-        budget: number;
-    }) => Uint32Array<ArrayBufferLike>;
+export declare function createSogStreamHandlers(
+  decodeSplats: (
+    args: SplatLoadArgs,
+    options: {
+      sendStatus: (data: SplatLoadStatus) => void;
+    },
+  ) => Promise<SplatResult>,
+): {
+  loadSogChunk: (
+    {
+      id,
+      ...args
+    }: SplatLoadArgs & {
+      id: number;
+    },
+    options: {
+      sendStatus: (data: SplatLoadStatus) => void;
+    },
+  ) => Promise<SogChunkInfo>;
+  cacheSogChunk: ({
+    id,
+    data,
+  }: {
+    id: number;
+    data: SplatResult;
+  }) => SogChunkInfo;
+  extractSogRegions: ({
+    id,
+    ranges,
+  }: {
+    id: number;
+    ranges: {
+      start: number;
+      count: number;
+    }[];
+  }) => import("../../../data/defines.js").ReorderedSplatResult[];
+  releaseSogChunk: ({
+    id,
+  }: {
+    id: number;
+  }) => void;
+  parseSogIndex: ({
+    bytes,
+    baseUrl,
+  }: {
+    bytes: ArrayBuffer;
+    baseUrl: string;
+  }) => {
+    bounds: Float64Array<ArrayBuffer>;
+    leafOffsets: Uint32Array<ArrayBuffer>;
+    lods: Float64Array<ArrayBuffer>;
+    retainedIndexBytes: number;
+    urls: string[];
+    counts: Float64Array;
+    environment?: string;
+  };
+  selectSogLod: ({
+    view,
+    budget,
+  }: {
+    view: SogView;
+    budget: number;
+  }) => Uint32Array<ArrayBufferLike>;
 };

package/dist/types/loaders/stream/streamOptions.d.cts

@@ -1,44 +1,53 @@
-import { Group, LoadingManager } from 'three';
-import { SplatRequestOptions } from '../loadTypes.cjs';
+import type { Group, LoadingManager } from "three";
+import type { SplatRequestOptions } from "../loadTypes.cjs";
 export type StreamRequestOptions = SplatRequestOptions & {
-    manager?: LoadingManager;
+  manager?: LoadingManager;
 };
 export type StreamSchedulerOptions = {
-    group?: Group;
-    /** Initial Splat budget; update scheduler.splatBudget to change it at runtime. */
-    splatBudget?: number;
-    /** Milliseconds to retain unused data after fade-out; defaults to 2000. */
-    cooldownMs?: number;
-    fadeDurationMs?: number;
-    /** Active downloads/decodes. Ready copies use a separate bounded byte queue. */
-    maxConcurrentLoads?: number;
-    onChange?: () => void;
-    onError?: (error: unknown, url: string) => void;
+  group?: Group;
+  /** Initial Splat budget; update scheduler.splatBudget to change it at runtime. */
+  splatBudget?: number;
+  /** Milliseconds to retain unused data after fade-out; defaults to 2000. */
+  cooldownMs?: number;
+  fadeDurationMs?: number;
+  /** Active downloads/decodes. Ready copies use a separate bounded byte queue. */
+  maxConcurrentLoads?: number;
+  onChange?: () => void;
+  onError?: (error: unknown, url: string) => void;
 };
 export type StreamStats = {
-    visibleSplats: number;
-    visibleMeshes: number;
-    residentMeshes: number;
-    /** Decoded chunks, including cached chunks that are not currently drawn. */
-    residentChunks: number;
-    /** Retained CPU and estimated GPU bytes, excluding pending copies and WASM. */
-    residentBytes: number;
-    /** Reserved or ready copies awaiting publication into source storage. */
-    pendingBytes: number;
-    loadingChunks: number;
-    downloadedBytes: number;
-    peakWasmMemoryBytes: number;
+  visibleSplats: number;
+  visibleMeshes: number;
+  residentMeshes: number;
+  /** Decoded chunks, including cached chunks that are not currently drawn. */
+  residentChunks: number;
+  /** Retained CPU and estimated GPU bytes, excluding pending copies and WASM. */
+  residentBytes: number;
+  /** Reserved or ready copies awaiting publication into source storage. */
+  pendingBytes: number;
+  loadingChunks: number;
+  downloadedBytes: number;
+  peakWasmMemoryBytes: number;
 };
 export declare function positiveInteger(value: number, name: string): number;
 export declare function streamSettings(options: StreamSchedulerOptions): {
-    splatBudget: number;
-    cooldownMs: number;
-    fadeDurationMs: number;
-    maxConcurrentLoads: number;
+  splatBudget: number;
+  cooldownMs: number;
+  fadeDurationMs: number;
+  maxConcurrentLoads: number;
 };
 /** Bound queued decode/extraction copies independently of per-update publication. */
-export declare function streamPendingLimit(concurrency: number, unitBytes?: number): number;
+export declare function streamPendingLimit(
+  concurrency: number,
+  unitBytes?: number,
+): number;
 /** Format errors are permanent; transient failures retry with capped backoff. */
 export declare function streamRetryAt(error: unknown, failures: number): number;
-export declare function notifyStreamChange(options: StreamSchedulerOptions): void;
-export declare function notifyStreamError(options: StreamSchedulerOptions, error: unknown, url: string): void;
+export declare function notifyStreamChange(
+  options: StreamSchedulerOptions,
+): void;
+export declare function notifyStreamError(
+  options: StreamSchedulerOptions,
+  error: unknown,
+  url: string,
+): void;

package/dist/types/loaders/stream/streamOptions.d.ts

@@ -1,44 +1,53 @@
-import { Group, LoadingManager } from 'three';
-import { SplatRequestOptions } from '../loadTypes';
+import type { Group, LoadingManager } from "three";
+import type { SplatRequestOptions } from "../loadTypes.js";
 export type StreamRequestOptions = SplatRequestOptions & {
-    manager?: LoadingManager;
+  manager?: LoadingManager;
 };
 export type StreamSchedulerOptions = {
-    group?: Group;
-    /** Initial Splat budget; update scheduler.splatBudget to change it at runtime. */
-    splatBudget?: number;
-    /** Milliseconds to retain unused data after fade-out; defaults to 2000. */
-    cooldownMs?: number;
-    fadeDurationMs?: number;
-    /** Active downloads/decodes. Ready copies use a separate bounded byte queue. */
-    maxConcurrentLoads?: number;
-    onChange?: () => void;
-    onError?: (error: unknown, url: string) => void;
+  group?: Group;
+  /** Initial Splat budget; update scheduler.splatBudget to change it at runtime. */
+  splatBudget?: number;
+  /** Milliseconds to retain unused data after fade-out; defaults to 2000. */
+  cooldownMs?: number;
+  fadeDurationMs?: number;
+  /** Active downloads/decodes. Ready copies use a separate bounded byte queue. */
+  maxConcurrentLoads?: number;
+  onChange?: () => void;
+  onError?: (error: unknown, url: string) => void;
 };
 export type StreamStats = {
-    visibleSplats: number;
-    visibleMeshes: number;
-    residentMeshes: number;
-    /** Decoded chunks, including cached chunks that are not currently drawn. */
-    residentChunks: number;
-    /** Retained CPU and estimated GPU bytes, excluding pending copies and WASM. */
-    residentBytes: number;
-    /** Reserved or ready copies awaiting publication into source storage. */
-    pendingBytes: number;
-    loadingChunks: number;
-    downloadedBytes: number;
-    peakWasmMemoryBytes: number;
+  visibleSplats: number;
+  visibleMeshes: number;
+  residentMeshes: number;
+  /** Decoded chunks, including cached chunks that are not currently drawn. */
+  residentChunks: number;
+  /** Retained CPU and estimated GPU bytes, excluding pending copies and WASM. */
+  residentBytes: number;
+  /** Reserved or ready copies awaiting publication into source storage. */
+  pendingBytes: number;
+  loadingChunks: number;
+  downloadedBytes: number;
+  peakWasmMemoryBytes: number;
 };
 export declare function positiveInteger(value: number, name: string): number;
 export declare function streamSettings(options: StreamSchedulerOptions): {
-    splatBudget: number;
-    cooldownMs: number;
-    fadeDurationMs: number;
-    maxConcurrentLoads: number;
+  splatBudget: number;
+  cooldownMs: number;
+  fadeDurationMs: number;
+  maxConcurrentLoads: number;
 };
 /** Bound queued decode/extraction copies independently of per-update publication. */
-export declare function streamPendingLimit(concurrency: number, unitBytes?: number): number;
+export declare function streamPendingLimit(
+  concurrency: number,
+  unitBytes?: number,
+): number;
 /** Format errors are permanent; transient failures retry with capped backoff. */
 export declare function streamRetryAt(error: unknown, failures: number): number;
-export declare function notifyStreamChange(options: StreamSchedulerOptions): void;
-export declare function notifyStreamError(options: StreamSchedulerOptions, error: unknown, url: string): void;
+export declare function notifyStreamChange(
+  options: StreamSchedulerOptions,
+): void;
+export declare function notifyStreamError(
+  options: StreamSchedulerOptions,
+  error: unknown,
+  url: string,
+): void;