gaussian-splat-lite 1.2.2 → 1.3.1

package/dist/types/rendering/webgpu/ProjectionCache.d.cts

@@ -1,36 +1,51 @@
-import { Node, StorageArrayTexture } from 'three/webgpu';
-import { SplatProjection } from '../tsl/ProjectionProgram.cjs';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { Node, StorageArrayTexture } from "three/webgpu";
+import type { SplatProjection } from "../tsl/ProjectionProgram.cjs";
 type TextureLimits = {
-    maxTextureDimension2D: number;
-    maxTextureArrayLayers: number;
+  maxTextureDimension2D: number;
+  maxTextureArrayLayers: number;
 };
-export declare function getProjectionCacheSize(count: number, limits: TextureLimits): {
-    width: number;
-    height: number;
-    depth: number;
+export declare function getProjectionCacheSize(
+  count: number,
+  limits: TextureLimits,
+): {
+  width: number;
+  height: number;
+  depth: number;
 };
 /** Native projected records: compact layout, paired codec and texture ownership. */
 export declare class ProjectionCache {
-    readonly textures: StorageArrayTexture[];
-    readonly size: THREE.Vector4;
-    private readonly dimensions;
-    resize(size: ReturnType<typeof getProjectionCacheSize>): void;
-    write(index: Node<"uint">, projection: SplatProjection, ndc: Node<"vec2">, pixelScale: Node<"vec2">, centerRange: Node<"float">): void;
-    /**
-     * A shared WebXR slot another eye draws: a transparent record whose
-     * corners collapse to one point, behind a perspective camera.
-     */
-    writeHidden(index: Node<"uint">): void;
-    read(index: Node<"uint">, pixelScale: Node<"vec2">, centerRange: Node<"float">, 
+  readonly textures: StorageArrayTexture[];
+  readonly size: THREE.Vector4;
+  private readonly dimensions;
+  resize(size: ReturnType<typeof getProjectionCacheSize>): void;
+  write(
+    index: Node<"uint">,
+    projection: SplatProjection,
+    ndc: Node<"vec2">,
+    pixelScale: Node<"vec2">,
+    centerRange: Node<"float">,
+  ): void;
+  /**
+   * A shared WebXR slot another eye draws: a transparent record whose
+   * corners collapse to one point, behind a perspective camera.
+   */
+  writeHidden(index: Node<"uint">): void;
+  read(
+    index: Node<"uint">,
+    pixelScale: Node<"vec2">,
+    centerRange: Node<"float">,
     /** NDC translation from the cached projection to the drawn one. */
-    jitter: Node<"vec2">): {
-        clipPosition: import('three/webgpu').VarNode<"vec4", import('three/webgpu').JoinNode<"vec4">>;
-        rgba: import('three/webgpu').VarNode<"vec4", import('three/webgpu').JoinNode<"vec4">>;
-        splatUv: Node<"vec2">;
-        supportRadiusSquared: Node<"float">;
-        kernelPower: Node<"float">;
-    };
-    dispose(): void;
+    jitter: Node<"vec2">,
+    /** Projection of the drawn eye. */
+    projectionMatrix: Node<"mat4">,
+  ): {
+    clipPosition: Node<"vec4">;
+    rgba: Node<"vec4">;
+    splatUv: Node<"vec2">;
+    supportRadiusSquared: Node<"float">;
+    kernelPower: Node<"float">;
+  };
+  dispose(): void;
 }
 export {};

package/dist/types/rendering/webgpu/ProjectionCache.d.ts

@@ -1,36 +1,51 @@
-import { Node, StorageArrayTexture } from 'three/webgpu';
-import { SplatProjection } from '../tsl/ProjectionProgram';
-import * as THREE from "three";
+import type * as THREE from "three";
+import type { Node, StorageArrayTexture } from "three/webgpu";
+import type { SplatProjection } from "../tsl/ProjectionProgram.js";
 type TextureLimits = {
-    maxTextureDimension2D: number;
-    maxTextureArrayLayers: number;
+  maxTextureDimension2D: number;
+  maxTextureArrayLayers: number;
 };
-export declare function getProjectionCacheSize(count: number, limits: TextureLimits): {
-    width: number;
-    height: number;
-    depth: number;
+export declare function getProjectionCacheSize(
+  count: number,
+  limits: TextureLimits,
+): {
+  width: number;
+  height: number;
+  depth: number;
 };
 /** Native projected records: compact layout, paired codec and texture ownership. */
 export declare class ProjectionCache {
-    readonly textures: StorageArrayTexture[];
-    readonly size: THREE.Vector4;
-    private readonly dimensions;
-    resize(size: ReturnType<typeof getProjectionCacheSize>): void;
-    write(index: Node<"uint">, projection: SplatProjection, ndc: Node<"vec2">, pixelScale: Node<"vec2">, centerRange: Node<"float">): void;
-    /**
-     * A shared WebXR slot another eye draws: a transparent record whose
-     * corners collapse to one point, behind a perspective camera.
-     */
-    writeHidden(index: Node<"uint">): void;
-    read(index: Node<"uint">, pixelScale: Node<"vec2">, centerRange: Node<"float">, 
+  readonly textures: StorageArrayTexture[];
+  readonly size: THREE.Vector4;
+  private readonly dimensions;
+  resize(size: ReturnType<typeof getProjectionCacheSize>): void;
+  write(
+    index: Node<"uint">,
+    projection: SplatProjection,
+    ndc: Node<"vec2">,
+    pixelScale: Node<"vec2">,
+    centerRange: Node<"float">,
+  ): void;
+  /**
+   * A shared WebXR slot another eye draws: a transparent record whose
+   * corners collapse to one point, behind a perspective camera.
+   */
+  writeHidden(index: Node<"uint">): void;
+  read(
+    index: Node<"uint">,
+    pixelScale: Node<"vec2">,
+    centerRange: Node<"float">,
     /** NDC translation from the cached projection to the drawn one. */
-    jitter: Node<"vec2">): {
-        clipPosition: import('three/webgpu').VarNode<"vec4", import('three/webgpu').JoinNode<"vec4">>;
-        rgba: import('three/webgpu').VarNode<"vec4", import('three/webgpu').JoinNode<"vec4">>;
-        splatUv: Node<"vec2">;
-        supportRadiusSquared: Node<"float">;
-        kernelPower: Node<"float">;
-    };
-    dispose(): void;
+    jitter: Node<"vec2">,
+    /** Projection of the drawn eye. */
+    projectionMatrix: Node<"mat4">,
+  ): {
+    clipPosition: Node<"vec4">;
+    rgba: Node<"vec4">;
+    splatUv: Node<"vec2">;
+    supportRadiusSquared: Node<"float">;
+    kernelPower: Node<"float">;
+  };
+  dispose(): void;
 }
 export {};

package/dist/types/rendering/webgpu/ProjectionKernel.d.cts

@@ -0,0 +1,22 @@
+import type { ComputeNode, StorageBufferNode } from "three/webgpu";
+import type { Uniforms } from "../uniforms.cjs";
+import type { ProjectionCache } from "./ProjectionCache.cjs";
+
+/** Builds a projection graph from bindings owned by ProjectedSplats. */
+export declare function createProjectionKernel({
+  uniforms,
+  eyeCount,
+  keys,
+  seeds,
+  sortValues,
+  counter,
+  cache,
+}: {
+  uniforms: Uniforms;
+  eyeCount: number;
+  keys: StorageBufferNode<"uint">;
+  seeds: StorageBufferNode<"uint">;
+  sortValues: StorageBufferNode<"uint">;
+  counter: StorageBufferNode<"uint">;
+  cache: ProjectionCache;
+}): ComputeNode;

package/dist/types/rendering/webgpu/ProjectionKernel.d.ts

@@ -0,0 +1,22 @@
+import type { ComputeNode, StorageBufferNode } from "three/webgpu";
+import type { Uniforms } from "../uniforms.js";
+import type { ProjectionCache } from "./ProjectionCache.js";
+
+/** Builds a projection graph from bindings owned by ProjectedSplats. */
+export declare function createProjectionKernel({
+  uniforms,
+  eyeCount,
+  keys,
+  seeds,
+  sortValues,
+  counter,
+  cache,
+}: {
+  uniforms: Uniforms;
+  eyeCount: number;
+  keys: StorageBufferNode<"uint">;
+  seeds: StorageBufferNode<"uint">;
+  sortValues: StorageBufferNode<"uint">;
+  counter: StorageBufferNode<"uint">;
+  cache: ProjectionCache;
+}): ComputeNode;

package/dist/types/rendering/webgpu/RadixSort.d.cts

@@ -1,4 +1,4 @@
-import { ComputeNode, Node, StorageBufferAttribute } from 'three/webgpu';
+import type { ComputeNode, Node, StorageBufferAttribute } from "three/webgpu";
 /**
  * Key layout of one sort: full 32-bit or fast 24-bit back-to-front keys, or
  * 16-bit front-to-back keys for stochastic ordering.
@@ -6,9 +6,9 @@ import { ComputeNode, Node, StorageBufferAttribute } from 'three/webgpu';
 export type RadixSortMode = "full" | "fast" | "front";
 /** Values of the GPU mode uniform. */
 export declare const RADIX_SORT_MODE_IDS: {
-    readonly full: 0;
-    readonly fast: 1;
-    readonly front: 2;
+  readonly full: 0;
+  readonly fast: 1;
+  readonly front: 2;
 };
 /**
  * Input key of an absent record. The first pass drops these records and
@@ -16,15 +16,15 @@ export declare const RADIX_SORT_MODE_IDS: {
  */
 export declare const INVALID_SORT_KEY = 4294967295;
 type BufferRef = {
-    value: StorageBufferAttribute;
+  value: StorageBufferAttribute;
 };
 type WebGPURadixSortOptions = {
-    /** GPU count of input keys other than INVALID_SORT_KEY. */
-    count: Node<"uint">;
-    /** RADIX_SORT_MODE_IDS value matching the input key encoding. */
-    mode: Node<"uint">;
-    maxComputeWorkgroupsPerDimension: number;
-    maxStorageBufferBindingSize: number;
+  /** GPU count of input keys other than INVALID_SORT_KEY. */
+  count: Node<"uint">;
+  /** RADIX_SORT_MODE_IDS value matching the input key encoding. */
+  mode: Node<"uint">;
+  maxComputeWorkgroupsPerDimension: number;
+  maxStorageBufferBindingSize: number;
 };
 /**
  * Stable 16-, 24- or 32-bit radix sort. The first pass compacts records whose
@@ -32,34 +32,38 @@ type WebGPURadixSortOptions = {
  * `inputValues`. Borrows and overwrites input keys; their owner manages storage.
  */
 export declare class WebGPURadixSort {
-    capacity: number;
-    readonly maxCapacity: number;
-    readonly nodes: ComputeNode[];
-    private readonly elementCount;
-    private readonly keys;
-    private readonly values;
-    private readonly blockSums;
-    private readonly counts;
-    private readonly sortDispatch;
-    private readonly prefixLevels;
-    private mode;
-    private readonly maxWorkgroups;
-    private readonly dispatchNodes;
-    constructor(capacity: number, inputKeys: BufferRef, options: WebGPURadixSortOptions);
-    /** Values the caller writes for valid input records; sorting overwrites them. */
-    get inputValues(): StorageBufferAttribute;
-    get ordering(): StorageBufferAttribute;
-    private validateCapacity;
-    private paddedWorkgroups;
-    private makeSetupTask;
-    private replaceBuffer;
-    private createPrefixLevels;
-    resize(capacity: number, shrinkResources?: boolean): void;
-    /**
-     * Prepare the persistent graph for this many input records. The GPU count
-     * of valid records is clamped to it.
-     */
-    prepare(elementCount: number, mode: RadixSortMode): ComputeNode[];
-    dispose(): void;
+  capacity: number;
+  readonly maxCapacity: number;
+  readonly nodes: ComputeNode[];
+  private readonly elementCount;
+  private readonly keys;
+  private readonly values;
+  private readonly blockSums;
+  private readonly counts;
+  private readonly sortDispatch;
+  private readonly prefixLevels;
+  private mode;
+  private readonly maxWorkgroups;
+  private readonly dispatchNodes;
+  constructor(
+    capacity: number,
+    inputKeys: BufferRef,
+    options: WebGPURadixSortOptions,
+  );
+  /** Values the caller writes for valid input records; sorting overwrites them. */
+  get inputValues(): StorageBufferAttribute;
+  get ordering(): StorageBufferAttribute;
+  private validateCapacity;
+  private paddedWorkgroups;
+  private makeSetupTask;
+  private replaceBuffer;
+  private createPrefixLevels;
+  resize(capacity: number, shrinkResources?: boolean): void;
+  /**
+   * Prepare the persistent graph for this many input records. The GPU count
+   * of valid records is clamped to it.
+   */
+  prepare(elementCount: number, mode: RadixSortMode): ComputeNode[];
+  dispose(): void;
 }
 export {};

package/dist/types/rendering/webgpu/RadixSort.d.ts

@@ -1,4 +1,4 @@
-import { ComputeNode, Node, StorageBufferAttribute } from 'three/webgpu';
+import type { ComputeNode, Node, StorageBufferAttribute } from "three/webgpu";
 /**
  * Key layout of one sort: full 32-bit or fast 24-bit back-to-front keys, or
  * 16-bit front-to-back keys for stochastic ordering.
@@ -6,9 +6,9 @@ import { ComputeNode, Node, StorageBufferAttribute } from 'three/webgpu';
 export type RadixSortMode = "full" | "fast" | "front";
 /** Values of the GPU mode uniform. */
 export declare const RADIX_SORT_MODE_IDS: {
-    readonly full: 0;
-    readonly fast: 1;
-    readonly front: 2;
+  readonly full: 0;
+  readonly fast: 1;
+  readonly front: 2;
 };
 /**
  * Input key of an absent record. The first pass drops these records and
@@ -16,15 +16,15 @@ export declare const RADIX_SORT_MODE_IDS: {
  */
 export declare const INVALID_SORT_KEY = 4294967295;
 type BufferRef = {
-    value: StorageBufferAttribute;
+  value: StorageBufferAttribute;
 };
 type WebGPURadixSortOptions = {
-    /** GPU count of input keys other than INVALID_SORT_KEY. */
-    count: Node<"uint">;
-    /** RADIX_SORT_MODE_IDS value matching the input key encoding. */
-    mode: Node<"uint">;
-    maxComputeWorkgroupsPerDimension: number;
-    maxStorageBufferBindingSize: number;
+  /** GPU count of input keys other than INVALID_SORT_KEY. */
+  count: Node<"uint">;
+  /** RADIX_SORT_MODE_IDS value matching the input key encoding. */
+  mode: Node<"uint">;
+  maxComputeWorkgroupsPerDimension: number;
+  maxStorageBufferBindingSize: number;
 };
 /**
  * Stable 16-, 24- or 32-bit radix sort. The first pass compacts records whose
@@ -32,34 +32,38 @@ type WebGPURadixSortOptions = {
  * `inputValues`. Borrows and overwrites input keys; their owner manages storage.
  */
 export declare class WebGPURadixSort {
-    capacity: number;
-    readonly maxCapacity: number;
-    readonly nodes: ComputeNode[];
-    private readonly elementCount;
-    private readonly keys;
-    private readonly values;
-    private readonly blockSums;
-    private readonly counts;
-    private readonly sortDispatch;
-    private readonly prefixLevels;
-    private mode;
-    private readonly maxWorkgroups;
-    private readonly dispatchNodes;
-    constructor(capacity: number, inputKeys: BufferRef, options: WebGPURadixSortOptions);
-    /** Values the caller writes for valid input records; sorting overwrites them. */
-    get inputValues(): StorageBufferAttribute;
-    get ordering(): StorageBufferAttribute;
-    private validateCapacity;
-    private paddedWorkgroups;
-    private makeSetupTask;
-    private replaceBuffer;
-    private createPrefixLevels;
-    resize(capacity: number, shrinkResources?: boolean): void;
-    /**
-     * Prepare the persistent graph for this many input records. The GPU count
-     * of valid records is clamped to it.
-     */
-    prepare(elementCount: number, mode: RadixSortMode): ComputeNode[];
-    dispose(): void;
+  capacity: number;
+  readonly maxCapacity: number;
+  readonly nodes: ComputeNode[];
+  private readonly elementCount;
+  private readonly keys;
+  private readonly values;
+  private readonly blockSums;
+  private readonly counts;
+  private readonly sortDispatch;
+  private readonly prefixLevels;
+  private mode;
+  private readonly maxWorkgroups;
+  private readonly dispatchNodes;
+  constructor(
+    capacity: number,
+    inputKeys: BufferRef,
+    options: WebGPURadixSortOptions,
+  );
+  /** Values the caller writes for valid input records; sorting overwrites them. */
+  get inputValues(): StorageBufferAttribute;
+  get ordering(): StorageBufferAttribute;
+  private validateCapacity;
+  private paddedWorkgroups;
+  private makeSetupTask;
+  private replaceBuffer;
+  private createPrefixLevels;
+  resize(capacity: number, shrinkResources?: boolean): void;
+  /**
+   * Prepare the persistent graph for this many input records. The GPU count
+   * of valid records is clamped to it.
+   */
+  prepare(elementCount: number, mode: RadixSortMode): ComputeNode[];
+  dispose(): void;
 }
 export {};

package/dist/types/rendering/webgpu/SplatBackend.d.cts

@@ -1,15 +1,17 @@
-import { WebGPURenderer } from 'three/webgpu';
-import { SplatMaterialOptions } from '../backend.cjs';
-import { NodeSplatBackend } from '../tsl/SplatBackend.cjs';
-import { Uniforms } from '../uniforms.cjs';
-import { ProjectedSplats } from './ProjectedSplats.cjs';
+import type { WebGPURenderer } from "three/webgpu";
+import type { SplatMaterialOptions } from "../backend.cjs";
+import { NodeSplatBackend } from "../tsl/SplatBackend.cjs";
+import type { Uniforms } from "../uniforms.cjs";
+import type { ProjectedSplats } from "./ProjectedSplats.cjs";
 /** Native WebGPU: fixed compute projection, visible compaction, GPU sort and indirect draw. */
 export declare class WebGPUSplatBackend extends NodeSplatBackend {
-    readonly kind = "webgpu";
-    readonly projection: ProjectedSplats;
-    precompile: Promise<void> | null;
-    constructor(renderer: WebGPURenderer, uniforms: Uniforms, options: SplatMaterialOptions);
-    get sortError(): unknown;
-    getOrderingCapacity(count: number): number;
-    dispose(): void;
+  readonly kind = "webgpu";
+  readonly projection: ProjectedSplats;
+  constructor(
+    renderer: WebGPURenderer,
+    uniforms: Uniforms,
+    options: SplatMaterialOptions,
+  );
+  getOrderingCapacity(count: number): number;
+  dispose(): void;
 }

package/dist/types/rendering/webgpu/SplatBackend.d.ts

@@ -1,15 +1,17 @@
-import { WebGPURenderer } from 'three/webgpu';
-import { SplatMaterialOptions } from '../backend';
-import { NodeSplatBackend } from '../tsl/SplatBackend';
-import { Uniforms } from '../uniforms';
-import { ProjectedSplats } from './ProjectedSplats';
+import type { WebGPURenderer } from "three/webgpu";
+import type { SplatMaterialOptions } from "../backend.js";
+import { NodeSplatBackend } from "../tsl/SplatBackend.js";
+import type { Uniforms } from "../uniforms.js";
+import type { ProjectedSplats } from "./ProjectedSplats.js";
 /** Native WebGPU: fixed compute projection, visible compaction, GPU sort and indirect draw. */
 export declare class WebGPUSplatBackend extends NodeSplatBackend {
-    readonly kind = "webgpu";
-    readonly projection: ProjectedSplats;
-    precompile: Promise<void> | null;
-    constructor(renderer: WebGPURenderer, uniforms: Uniforms, options: SplatMaterialOptions);
-    get sortError(): unknown;
-    getOrderingCapacity(count: number): number;
-    dispose(): void;
+  readonly kind = "webgpu";
+  readonly projection: ProjectedSplats;
+  constructor(
+    renderer: WebGPURenderer,
+    uniforms: Uniforms,
+    options: SplatMaterialOptions,
+  );
+  getOrderingCapacity(count: number): number;
+  dispose(): void;
 }

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

@@ -1,19 +1,23 @@
-import { WorkerRpc } from './WorkerRpc.cjs';
-import { RpcHandlers } from './worker.cjs';
+import { WorkerRpc } from "./WorkerRpc.cjs";
+import type { RpcHandlers } from "./worker.cjs";
 export declare class SplatWorker extends WorkerRpc<RpcHandlers> {
-    constructor(onDispose?: () => void);
+  constructor(onDispose?: () => void);
 }
 declare class SplatWorkerPool {
-    private readonly maxWorkers;
-    private heavyJobs;
-    numWorkers: number;
-    freelist: SplatWorker[];
-    idleWorkerTimeouts: Map<SplatWorker, number>;
-    queue: ((worker: SplatWorker) => void)[];
-    constructor(maxWorkers?: number);
-    withWorker<T>(callback: (worker: SplatWorker) => Promise<T>, memoryHeavy?: boolean, signal?: AbortSignal): Promise<T>;
-    allocWorker(): Promise<SplatWorker>;
-    freeWorker(worker: SplatWorker): void;
+  private readonly maxWorkers;
+  private heavyJobs;
+  numWorkers: number;
+  freelist: SplatWorker[];
+  idleWorkerTimeouts: Map<SplatWorker, number>;
+  queue: ((worker: SplatWorker) => void)[];
+  constructor(maxWorkers?: number);
+  withWorker<T>(
+    callback: (worker: SplatWorker) => Promise<T>,
+    memoryHeavy?: boolean,
+    signal?: AbortSignal,
+  ): Promise<T>;
+  allocWorker(): Promise<SplatWorker>;
+  freeWorker(worker: SplatWorker): void;
 }
 export declare const workerPool: SplatWorkerPool;
 export {};

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

@@ -1,19 +1,23 @@
-import { WorkerRpc } from './WorkerRpc';
-import { RpcHandlers } from './worker';
+import { WorkerRpc } from "./WorkerRpc.js";
+import type { RpcHandlers } from "./worker.js";
 export declare class SplatWorker extends WorkerRpc<RpcHandlers> {
-    constructor(onDispose?: () => void);
+  constructor(onDispose?: () => void);
 }
 declare class SplatWorkerPool {
-    private readonly maxWorkers;
-    private heavyJobs;
-    numWorkers: number;
-    freelist: SplatWorker[];
-    idleWorkerTimeouts: Map<SplatWorker, number>;
-    queue: ((worker: SplatWorker) => void)[];
-    constructor(maxWorkers?: number);
-    withWorker<T>(callback: (worker: SplatWorker) => Promise<T>, memoryHeavy?: boolean, signal?: AbortSignal): Promise<T>;
-    allocWorker(): Promise<SplatWorker>;
-    freeWorker(worker: SplatWorker): void;
+  private readonly maxWorkers;
+  private heavyJobs;
+  numWorkers: number;
+  freelist: SplatWorker[];
+  idleWorkerTimeouts: Map<SplatWorker, number>;
+  queue: ((worker: SplatWorker) => void)[];
+  constructor(maxWorkers?: number);
+  withWorker<T>(
+    callback: (worker: SplatWorker) => Promise<T>,
+    memoryHeavy?: boolean,
+    signal?: AbortSignal,
+  ): Promise<T>;
+  allocWorker(): Promise<SplatWorker>;
+  freeWorker(worker: SplatWorker): void;
 }
 export declare const workerPool: SplatWorkerPool;
 export {};

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

@@ -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 {};