gaussian-splat-lite 1.2.2 → 1.3.1

package/dist/types/runtime/WorkerRpc.d.ts

@@ -1,29 +1,35 @@
 type PromiseRecord = {
-    resolve: (value: unknown) => void;
-    reject: (reason?: unknown) => void;
-    onStatus?: (data: unknown) => void | Promise<void>;
-    statusQueue: Promise<void>;
+  resolve: (value: unknown) => void;
+  reject: (reason?: unknown) => void;
+  onStatus?: (data: unknown) => void | Promise<void>;
+  statusQueue: Promise<void>;
 };
 /** Transport/cache loss is recoverable by obtaining a fresh worker. */
 export declare class WorkerTerminatedError extends Error {
-    constructor(reason?: unknown);
+  constructor(reason?: unknown);
 }
 /** Typed main-thread transport shared by ordinary and streaming workers. */
-export declare class WorkerRpc<Handlers extends {
+export declare class WorkerRpc<
+  Handlers extends {
     [K in keyof Handlers]: (...args: never[]) => unknown;
-}> {
-    readonly worker: Worker;
-    private readonly onDispose?;
-    messages: Record<number, PromiseRecord>;
-    peakWasmMemoryBytes: number;
-    disposed: boolean;
-    static currentId: number;
-    constructor(worker: Worker, onDispose?: (() => void) | undefined);
-    onMessage(event: MessageEvent): void;
-    call<Name extends keyof Handlers>(name: Name, args: Parameters<Handlers[Name]>[0], options?: {
-        onStatus?: (data: unknown) => void | Promise<void>;
-        signal?: AbortSignal;
-    }): Promise<Awaited<ReturnType<Handlers[Name]>>>;
-    dispose(reason?: unknown): void;
+  },
+> {
+  readonly worker: Worker;
+  private readonly onDispose?;
+  messages: Record<number, PromiseRecord>;
+  peakWasmMemoryBytes: number;
+  disposed: boolean;
+  static currentId: number;
+  constructor(worker: Worker, onDispose?: (() => void) | undefined);
+  onMessage(event: MessageEvent): void;
+  call<Name extends keyof Handlers>(
+    name: Name,
+    args: Parameters<Handlers[Name]>[0],
+    options?: {
+      onStatus?: (data: unknown) => void | Promise<void>;
+      signal?: AbortSignal;
+    },
+  ): Promise<Awaited<ReturnType<Handlers[Name]>>>;
+  dispose(reason?: unknown): void;
 }
 export {};

package/dist/types/runtime/abort.d.cts

@@ -1,8 +1,13 @@
 /** Reject promptly on cancellation while still observing the underlying task. */
-export declare function abortable<T>(task: Promise<T>, signal?: AbortSignal): Promise<T>;
+export declare function abortable<T>(
+  task: Promise<T>,
+  signal?: AbortSignal,
+): Promise<T>;
 /** Link lifetime and per-request cancellation without retaining completed listeners. */
-export declare function linkedAbortController(...signals: (AbortSignal | undefined)[]): {
-    controller: AbortController;
-    signal: AbortSignal;
-    cleanup(): void;
+export declare function linkedAbortController(
+  ...signals: (AbortSignal | undefined)[]
+): {
+  controller: AbortController;
+  signal: AbortSignal;
+  cleanup(): void;
 };

package/dist/types/runtime/abort.d.ts

@@ -1,8 +1,13 @@
 /** Reject promptly on cancellation while still observing the underlying task. */
-export declare function abortable<T>(task: Promise<T>, signal?: AbortSignal): Promise<T>;
+export declare function abortable<T>(
+  task: Promise<T>,
+  signal?: AbortSignal,
+): Promise<T>;
 /** Link lifetime and per-request cancellation without retaining completed listeners. */
-export declare function linkedAbortController(...signals: (AbortSignal | undefined)[]): {
-    controller: AbortController;
-    signal: AbortSignal;
-    cleanup(): void;
+export declare function linkedAbortController(
+  ...signals: (AbortSignal | undefined)[]
+): {
+  controller: AbortController;
+  signal: AbortSignal;
+  cleanup(): void;
 };

package/dist/types/runtime/retry.d.cts

@@ -2,10 +2,10 @@
 export declare function retryDelay(failures: number): number;
 /** Wake on-demand render loops at the next retry, without polling idle scenes. */
 export declare class RetryTimer {
-    private readonly wake;
-    private timer?;
-    private deadline;
-    constructor(wake: () => void);
-    update(deadlines: Iterable<number>): void;
-    dispose(): void;
+  private readonly wake;
+  private timer?;
+  private deadline;
+  constructor(wake: () => void);
+  update(deadlines: Iterable<number>): void;
+  dispose(): void;
 }

package/dist/types/runtime/retry.d.ts

@@ -2,10 +2,10 @@
 export declare function retryDelay(failures: number): number;
 /** Wake on-demand render loops at the next retry, without polling idle scenes. */
 export declare class RetryTimer {
-    private readonly wake;
-    private timer?;
-    private deadline;
-    constructor(wake: () => void);
-    update(deadlines: Iterable<number>): void;
-    dispose(): void;
+  private readonly wake;
+  private timer?;
+  private deadline;
+  constructor(wake: () => void);
+  update(deadlines: Iterable<number>): void;
+  dispose(): void;
 }

package/dist/types/runtime/wasmCall.d.cts

@@ -1,12 +1,12 @@
 /** Known allocation failures; invalid array lengths and bounds traps are not OOM. */
 export declare function isMemoryAllocationError(error: unknown): boolean;
 export declare function wasmFailure(): {
-    failed: boolean;
-    error: unknown;
+  failed: boolean;
+  error: unknown;
 };
 /** Free a WASM object unless a failure left its instance unrecoverable. */
 export declare function wasmFree(value?: {
-    free(): void;
+  free(): void;
 }): void;
 /** Traps and glue allocation failures can leave Rust borrows unrecoverable. */
 export declare function wasmCall<T>(call: () => T): T;

package/dist/types/runtime/wasmCall.d.ts

@@ -1,12 +1,12 @@
 /** Known allocation failures; invalid array lengths and bounds traps are not OOM. */
 export declare function isMemoryAllocationError(error: unknown): boolean;
 export declare function wasmFailure(): {
-    failed: boolean;
-    error: unknown;
+  failed: boolean;
+  error: unknown;
 };
 /** Free a WASM object unless a failure left its instance unrecoverable. */
 export declare function wasmFree(value?: {
-    free(): void;
+  free(): void;
 }): void;
 /** Traps and glue allocation failures can leave Rust borrows unrecoverable. */
 export declare function wasmCall<T>(call: () => T): T;

package/dist/types/runtime/worker.d.cts

@@ -1,32 +1,52 @@
-import { loadSplats, resolveAsset, resolveFile } from '../loaders/workerDecode.cjs';
+import type {
+  loadSplats,
+  resolveAsset,
+  resolveFile,
+} from "../loaders/workerDecode.cjs";
 declare const rpcHandlers: {
-    setSortCenterState: typeof setSortCenterState;
-    sortCenters32: typeof sortCenters32;
-    loadSplats: typeof loadSplats;
-    resolveAsset: typeof resolveAsset;
-    resolveFile: typeof resolveFile;
+  setSortCenterState: typeof setSortCenterState;
+  sortCenters32: typeof sortCenters32;
+  loadSplats: typeof loadSplats;
+  resolveAsset: typeof resolveAsset;
+  resolveFile: typeof resolveFile;
 };
 export type RpcHandlers = typeof rpcHandlers;
-declare function setSortCenterState({ centerUpdateRangeIndices, updateCenters, matrixUpdateRangeIndices, updateMatrices, rangeMeshIds, rangeBases, rangeCounts, }: {
-    centerUpdateRangeIndices: Uint32Array;
-    updateCenters: Float32Array;
-    matrixUpdateRangeIndices: Uint32Array;
-    updateMatrices: Float64Array;
-    rangeMeshIds: Uint32Array;
-    rangeBases: Uint32Array;
-    rangeCounts: Uint32Array;
+declare function setSortCenterState({
+  centerUpdateRangeIndices,
+  updateCenters,
+  matrixUpdateRangeIndices,
+  updateMatrices,
+  rangeMeshIds,
+  rangeBases,
+  rangeCounts,
+}: {
+  centerUpdateRangeIndices: Uint32Array;
+  updateCenters: Float32Array;
+  matrixUpdateRangeIndices: Uint32Array;
+  updateMatrices: Float64Array;
+  rangeMeshIds: Uint32Array;
+  rangeBases: Uint32Array;
+  rangeCounts: Uint32Array;
 }): void;
 /** Orders the Splats for one viewpoint; returns the active count. */
-declare function sortCenters32({ numSplats, cameraPosition, direction, radial, fastSort, frontSort, ordering, }: {
-    numSplats: number;
-    cameraPosition: [number, number, number];
-    direction: [number, number, number];
-    radial: boolean;
-    fastSort: boolean;
-    frontSort: boolean;
-    ordering: Uint32Array;
+declare function sortCenters32({
+  numSplats,
+  cameraPosition,
+  direction,
+  radial,
+  fastSort,
+  frontSort,
+  ordering,
+}: {
+  numSplats: number;
+  cameraPosition: [number, number, number];
+  direction: [number, number, number];
+  radial: boolean;
+  fastSort: boolean;
+  frontSort: boolean;
+  ordering: Uint32Array;
 }): {
-    ordering: Uint32Array<ArrayBufferLike>;
-    activeSplats: number;
+  ordering: Uint32Array<ArrayBufferLike>;
+  activeSplats: number;
 };
 export {};

package/dist/types/runtime/worker.d.ts

@@ -1,32 +1,52 @@
-import { loadSplats, resolveAsset, resolveFile } from '../loaders/workerDecode';
+import type {
+  loadSplats,
+  resolveAsset,
+  resolveFile,
+} from "../loaders/workerDecode.js";
 declare const rpcHandlers: {
-    setSortCenterState: typeof setSortCenterState;
-    sortCenters32: typeof sortCenters32;
-    loadSplats: typeof loadSplats;
-    resolveAsset: typeof resolveAsset;
-    resolveFile: typeof resolveFile;
+  setSortCenterState: typeof setSortCenterState;
+  sortCenters32: typeof sortCenters32;
+  loadSplats: typeof loadSplats;
+  resolveAsset: typeof resolveAsset;
+  resolveFile: typeof resolveFile;
 };
 export type RpcHandlers = typeof rpcHandlers;
-declare function setSortCenterState({ centerUpdateRangeIndices, updateCenters, matrixUpdateRangeIndices, updateMatrices, rangeMeshIds, rangeBases, rangeCounts, }: {
-    centerUpdateRangeIndices: Uint32Array;
-    updateCenters: Float32Array;
-    matrixUpdateRangeIndices: Uint32Array;
-    updateMatrices: Float64Array;
-    rangeMeshIds: Uint32Array;
-    rangeBases: Uint32Array;
-    rangeCounts: Uint32Array;
+declare function setSortCenterState({
+  centerUpdateRangeIndices,
+  updateCenters,
+  matrixUpdateRangeIndices,
+  updateMatrices,
+  rangeMeshIds,
+  rangeBases,
+  rangeCounts,
+}: {
+  centerUpdateRangeIndices: Uint32Array;
+  updateCenters: Float32Array;
+  matrixUpdateRangeIndices: Uint32Array;
+  updateMatrices: Float64Array;
+  rangeMeshIds: Uint32Array;
+  rangeBases: Uint32Array;
+  rangeCounts: Uint32Array;
 }): void;
 /** Orders the Splats for one viewpoint; returns the active count. */
-declare function sortCenters32({ numSplats, cameraPosition, direction, radial, fastSort, frontSort, ordering, }: {
-    numSplats: number;
-    cameraPosition: [number, number, number];
-    direction: [number, number, number];
-    radial: boolean;
-    fastSort: boolean;
-    frontSort: boolean;
-    ordering: Uint32Array;
+declare function sortCenters32({
+  numSplats,
+  cameraPosition,
+  direction,
+  radial,
+  fastSort,
+  frontSort,
+  ordering,
+}: {
+  numSplats: number;
+  cameraPosition: [number, number, number];
+  direction: [number, number, number];
+  radial: boolean;
+  fastSort: boolean;
+  frontSort: boolean;
+  ordering: Uint32Array;
 }): {
-    ordering: Uint32Array<ArrayBufferLike>;
-    activeSplats: number;
+  ordering: Uint32Array<ArrayBufferLike>;
+  activeSplats: number;
 };
 export {};

package/dist/types/runtime/workerServer.d.cts

@@ -1,2 +1,4 @@
 /** Start a worker with its own RPC table and WASM instance. */
-export declare function startWorker(rpcHandlers: Record<string, (...args: never[]) => unknown>): void;
+export declare function startWorker(
+  rpcHandlers: Record<string, (...args: never[]) => unknown>,
+): void;

package/dist/types/runtime/workerServer.d.ts

@@ -1,2 +1,4 @@
 /** Start a worker with its own RPC table and WASM instance. */
-export declare function startWorker(rpcHandlers: Record<string, (...args: never[]) => unknown>): void;
+export declare function startWorker(
+  rpcHandlers: Record<string, (...args: never[]) => unknown>,
+): void;

package/dist/types/scene/SplatEdit.d.cts

@@ -1,90 +1,97 @@
 import * as THREE from "three";
 export declare enum SplatEditSdfType {
-    ALL = "all",
-    PLANE = "plane",
-    SPHERE = "sphere",
-    BOX = "box",
-    ELLIPSOID = "ellipsoid",
-    CYLINDER = "cylinder",
-    CAPSULE = "capsule",
-    INFINITE_CONE = "infinite_cone"
+  ALL = "all",
+  PLANE = "plane",
+  SPHERE = "sphere",
+  BOX = "box",
+  ELLIPSOID = "ellipsoid",
+  CYLINDER = "cylinder",
+  CAPSULE = "capsule",
+  INFINITE_CONE = "infinite_cone",
 }
 /** RGBA-only operations supported by the SDF pipeline. */
 export declare enum SplatEditRgbaBlendMode {
-    MULTIPLY_RGBA = "multiply_rgba",
-    SET_RGBA = "set_rgba",
-    ADD_RGBA = "add_rgba"
+  MULTIPLY_RGBA = "multiply_rgba",
+  SET_RGBA = "set_rgba",
+  ADD_RGBA = "add_rgba",
 }
 export type SplatEditSdfColor = {
-    r?: number;
-    g?: number;
-    b?: number;
+  r?: number;
+  g?: number;
+  b?: number;
 };
 export type SplatEditSdfOptions = {
-    type?: SplatEditSdfType;
-    invert?: boolean;
-    opacity?: number;
-    color?: SplatEditSdfColor;
-    radius?: number;
+  type?: SplatEditSdfType;
+  invert?: boolean;
+  opacity?: number;
+  color?: SplatEditSdfColor;
+  radius?: number;
 };
 /** A signed-distance shape carrying optional color and opacity channels. */
 export declare class SplatEditSdf extends THREE.Object3D {
-    type: SplatEditSdfType;
-    invert: boolean;
-    opacity?: number;
-    color: SplatEditSdfColor;
-    radius: number;
-    constructor(options?: SplatEditSdfOptions);
+  type: SplatEditSdfType;
+  invert: boolean;
+  opacity?: number;
+  color: SplatEditSdfColor;
+  radius: number;
+  constructor(options?: SplatEditSdfOptions);
 }
 export type SplatEditOptions = {
-    name?: string;
-    rgbaBlendMode?: SplatEditRgbaBlendMode;
-    sdfSmooth?: number;
-    softEdge?: number;
-    invert?: boolean;
-    sdfs?: SplatEditSdf[];
+  name?: string;
+  rgbaBlendMode?: SplatEditRgbaBlendMode;
+  sdfSmooth?: number;
+  softEdge?: number;
+  invert?: boolean;
+  sdfs?: SplatEditSdf[];
 };
 /** An ordered RGBA operation evaluated over one or more SDF shapes. */
 export declare class SplatEdit extends THREE.Object3D {
-    ordering: number;
-    rgbaBlendMode: SplatEditRgbaBlendMode;
-    sdfSmooth: number;
-    softEdge: number;
-    invert: boolean;
-    sdfs: SplatEditSdf[] | null;
-    static nextOrdering: number;
-    constructor(options?: SplatEditOptions);
-    addSdf(sdf: SplatEditSdf): void;
-    removeSdf(sdf: SplatEditSdf): void;
+  ordering: number;
+  rgbaBlendMode: SplatEditRgbaBlendMode;
+  sdfSmooth: number;
+  softEdge: number;
+  invert: boolean;
+  sdfs: SplatEditSdf[] | null;
+  static nextOrdering: number;
+  constructor(options?: SplatEditOptions);
+  addSdf(sdf: SplatEditSdf): void;
+  removeSdf(sdf: SplatEditSdf): void;
 }
 export type SplatEditGroup = {
-    edit: SplatEdit;
-    sdfs: SplatEditSdf[];
+  edit: SplatEdit;
+  sdfs: SplatEditSdf[];
 };
 /** Encodes SDF geometry/RGBA and edit operations as regular integer textures. */
 export declare class SplatEdits {
-    maxSdfs: number;
-    numSdfs: number;
-    sdfData: Uint32Array;
-    sdfTexture: THREE.DataTexture;
-    maxEdits: number;
-    numEdits: number;
-    editData: Uint32Array;
-    editTexture: THREE.DataTexture;
-    constructor({ maxSdfs, maxEdits }?: {
-        maxSdfs?: number | undefined;
-        maxEdits?: number | undefined;
-    });
-    dispose(): void;
-    update(groups: SplatEditGroup[], coordinateOrigin?: THREE.Vector3): {
-        updated: boolean;
-    };
-    private ensureCapacity;
-    private encodeEdit;
-    private encodeSdf;
-    private setSdfUint;
-    private setSdfFloat;
-    private setEditUint;
-    private setEditFloat;
-    static emptyTexture: THREE.DataTexture;
+  maxSdfs: number;
+  numSdfs: number;
+  sdfData: Uint32Array;
+  sdfTexture: THREE.DataTexture;
+  maxEdits: number;
+  numEdits: number;
+  editData: Uint32Array;
+  editTexture: THREE.DataTexture;
+  constructor({
+    maxSdfs,
+    maxEdits,
+  }?: {
+    maxSdfs?: number | undefined;
+    maxEdits?: number | undefined;
+  });
+  dispose(): void;
+  update(
+    groups: SplatEditGroup[],
+    coordinateOrigin?: THREE.Vector3,
+    shrinkResources?: boolean,
+  ): {
+    updated: boolean;
+  };
+  private ensureCapacity;
+  private encodeEdit;
+  private encodeSdf;
+  private setSdfUint;
+  private setSdfFloat;
+  private setEditUint;
+  private setEditFloat;
+  static emptyTexture: THREE.DataTexture;
 }